ANDROID: fuse-bpf v1
Bug: 202785178
Test: test_fuse passes on linux, feature works on cuttlefish
Signed-off-by: Paul Lawrence <paullawrence@google.com>
Signed-off-by: Daniel Rosenberg <drosen@google.com>
Change-Id: I987684b799b07391ccde350e98fde7976f5601aa
diff --git a/fs/fuse/Kconfig b/fs/fuse/Kconfig
index 40ce9a1..d6bd90b5 100644
--- a/fs/fuse/Kconfig
+++ b/fs/fuse/Kconfig
@@ -52,3 +52,11 @@
If you want to allow mounting a Virtio Filesystem with the "dax"
option, answer Y.
+
+config FUSE_BPF
+ bool "Adds BPF to fuse"
+ depends on FUSE_FS
+ depends on BPF
+ help
+ Extends FUSE by adding BPF to prefilter calls and potentially pass to a
+ backing file system
diff --git a/fs/fuse/Makefile b/fs/fuse/Makefile
index 20ed23a..7bd922f 100644
--- a/fs/fuse/Makefile
+++ b/fs/fuse/Makefile
@@ -7,8 +7,8 @@
obj-$(CONFIG_CUSE) += cuse.o
obj-$(CONFIG_VIRTIO_FS) += virtiofs.o
-fuse-y := dev.o dir.o file.o inode.o control.o xattr.o acl.o readdir.o
-fuse-y += passthrough.o
+fuse-y := dev.o dir.o file.o inode.o control.o xattr.o acl.o readdir.o passthrough.o
fuse-$(CONFIG_FUSE_DAX) += dax.o
+fuse-$(CONFIG_FUSE_BPF) += backing.o
virtiofs-y := virtio_fs.o
diff --git a/fs/fuse/backing.c b/fs/fuse/backing.c
new file mode 100644
index 0000000..f30fe8e
--- /dev/null
+++ b/fs/fuse/backing.c
@@ -0,0 +1,1924 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * FUSE-BPF: Filesystem in Userspace with BPF
+ * Copyright (c) 2021 Google LLC
+ */
+
+#include "fuse_i.h"
+
+#include <linux/fdtable.h>
+#include <linux/filter.h>
+#include <linux/fs_stack.h>
+#include <linux/namei.h>
+
+#include "../internal.h"
+
+/* Reimplement these functions since fget_task is not exported */
+static struct file *fuse__fget_files(struct files_struct *files,
+ unsigned int fd, fmode_t mask, unsigned int refs)
+{
+ struct file *file;
+
+ rcu_read_lock();
+loop:
+ file = fcheck_files(files, fd);
+ if (file) {
+ /* File object ref couldn't be taken.
+ * dup2() atomicity guarantee is the reason
+ * we loop to catch the new file (or NULL pointer)
+ */
+ if (file->f_mode & mask)
+ file = NULL;
+ else if (!get_file_rcu_many(file, refs))
+ goto loop;
+ }
+ rcu_read_unlock();
+ return file;
+}
+
+static struct file *fuse_fget_task(struct task_struct *task, unsigned int fd)
+{
+ struct file *file = NULL;
+
+ task_lock(task);
+ if (task->files)
+ file = fuse__fget_files(task->files, fd, 0, 1);
+ task_unlock(task);
+
+ return file;
+}
+
+struct file *fuse_fget(struct fuse_conn *fc, unsigned int fd)
+{
+ return fuse_fget_task(fc->task, fd);
+}
+
+struct bpf_prog *fuse_get_bpf_prog(struct fuse_conn *fc, unsigned int fd)
+{
+ struct file *bpf_file = fuse_fget(fc, fd);
+ struct bpf_prog *bpf_prog = ERR_PTR(-EINVAL);
+
+ if (!bpf_file)
+ goto out;
+ /**
+ * Two ways of getting a bpf prog from another task's fd, since
+ * bpf_prog_get_type_dev only works with an fd
+ *
+ * 1) Duplicate a little of the needed code. Requires access to
+ * bpf_prog_fops for validation, which is not exported for modules
+ * 2) Insert the bpf_file object into a fd from the current task
+ * Stupidly complex, but I think OK, as security checks are not run
+ * during the existence of the handle
+ *
+ * Best would be to upstream 1) into kernel/bpf/syscall.c and export it
+ * for use here. Failing that, we have to use 2, since fuse must be
+ * compilable as a module.
+ */
+#if 0
+ if (bpf_file->f_op != &bpf_prog_fops)
+ goto out;
+
+ bpf_prog = bpf_file->private_data;
+ if (bpf_prog->type == BPF_PROG_TYPE_FUSE)
+ bpf_prog_inc(bpf_prog);
+ else
+ bpf_prog = ERR_PTR(-EINVAL);
+
+#else
+ {
+ int task_fd = get_unused_fd_flags(bpf_file->f_flags);
+
+ if (task_fd < 0)
+ goto out;
+ fd_install(task_fd, bpf_file);
+
+ bpf_prog = bpf_prog_get_type_dev(task_fd, BPF_PROG_TYPE_FUSE,
+ false);
+ __close_fd(current->files, task_fd);
+
+ /* TODO I think this file is probably being leaked */
+ bpf_file = NULL;
+ }
+#endif
+
+out:
+ if (bpf_file)
+ fput(bpf_file);
+ return bpf_prog;
+}
+
+int fuse_open_initialize(struct fuse_args *fa, struct fuse_open_io *foio,
+ struct inode *inode, struct file *file, bool isdir)
+{
+ foio->foi = (struct fuse_open_in) {
+ .flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY),
+ };
+
+ foio->foo = (struct fuse_open_out) {0};
+
+ *fa = (struct fuse_args) {
+ .nodeid = get_fuse_inode(inode)->nodeid,
+ .opcode = isdir ? FUSE_OPENDIR : FUSE_OPEN,
+ .in_numargs = 1,
+ .out_numargs = 1,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = sizeof(foio->foi),
+ .value = &foio->foi,
+ },
+ .out_args[0] = (struct fuse_arg) {
+ .size = sizeof(foio->foo),
+ .value = &foio->foo,
+ },
+ };
+
+ return 0;
+}
+
+int fuse_open_backing(struct fuse_args *fa,
+ struct inode *inode, struct file *file, bool isdir)
+{
+ struct fuse_mount *fm = get_fuse_mount(inode);
+ const struct fuse_open_in *foi = fa->in_args[0].value;
+ struct fuse_file *ff;
+ struct fuse_dentry *fd = get_fuse_dentry(file->f_path.dentry);
+ struct file *backing_file;
+
+ ff = fuse_file_alloc(fm);
+ if (!ff)
+ return -ENOMEM;
+ file->private_data = ff;
+
+ backing_file = dentry_open(&fd->backing_path,
+ foi->flags,
+ current_cred());
+ if (IS_ERR(backing_file)) {
+ fuse_file_free(ff);
+ file->private_data = NULL;
+ return PTR_ERR(backing_file);
+ }
+ ff->backing_file = backing_file;
+
+ return 0;
+}
+
+void *fuse_open_finalize(struct fuse_args *fa,
+ struct inode *inode, struct file *file, bool isdir)
+{
+ struct fuse_file *ff = file->private_data;
+ struct fuse_open_out *foo = fa->out_args[0].value;
+
+ ff->fh = foo->fh;
+ return 0;
+}
+
+int fuse_create_open_initialize(
+ struct fuse_args *fa, struct fuse_create_open_io *fcoio,
+ struct inode *dir, struct dentry *entry,
+ struct file *file, unsigned int flags, umode_t mode)
+{
+ fcoio->fci = (struct fuse_create_in) {
+ .flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY),
+ .mode = mode,
+ };
+
+ fcoio->feo = (struct fuse_entry_out) {0};
+ fcoio->foo = (struct fuse_open_out) {0};
+
+ *fa = (struct fuse_args) {
+ .nodeid = get_node_id(dir),
+ .opcode = FUSE_CREATE,
+ .in_numargs = 2,
+ .out_numargs = 2,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = sizeof(fcoio->fci),
+ .value = &fcoio->fci,
+ },
+ .in_args[1] = (struct fuse_in_arg) {
+ .size = entry->d_name.len + 1,
+ .value = entry->d_name.name,
+ },
+ .out_args[0] = (struct fuse_arg) {
+ .size = sizeof(fcoio->feo),
+ .value = &fcoio->feo,
+ },
+ .out_args[1] = (struct fuse_arg) {
+ .size = sizeof(fcoio->foo),
+ .value = &fcoio->foo,
+ },
+ };
+
+ return 0;
+}
+
+static int fuse_open_file_backing(struct inode *inode, struct file *file)
+{
+ struct fuse_mount *fm = get_fuse_mount(inode);
+ struct dentry *entry = file->f_path.dentry;
+ struct fuse_dentry *fuse_dentry = get_fuse_dentry(entry);
+ struct fuse_file *fuse_file;
+ struct file *backing_file;
+
+ fuse_file = fuse_file_alloc(fm);
+ if (!fuse_file)
+ return -ENOMEM;
+ file->private_data = fuse_file;
+
+ backing_file = dentry_open(&fuse_dentry->backing_path, file->f_flags,
+ current_cred());
+ if (IS_ERR(backing_file)) {
+ fuse_file_free(fuse_file);
+ file->private_data = NULL;
+ return PTR_ERR(backing_file);
+ }
+ fuse_file->backing_file = backing_file;
+
+ return 0;
+}
+
+int fuse_create_open_backing(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry,
+ struct file *file, unsigned int flags, umode_t mode)
+{
+ struct fuse_inode *dir_fuse_inode = get_fuse_inode(dir);
+ struct fuse_dentry *dir_fuse_dentry = get_fuse_dentry(entry->d_parent);
+ struct dentry *backing_dentry = NULL;
+ struct inode *inode = NULL;
+ struct dentry *newent;
+ int err = 0;
+ const struct fuse_create_in *fci = fa->in_args[0].value;
+
+ if (!dir_fuse_inode || !dir_fuse_dentry)
+ return -EIO;
+
+ inode_lock_nested(dir_fuse_inode->backing_inode, I_MUTEX_PARENT);
+ backing_dentry = lookup_one_len(fa->in_args[1].value,
+ dir_fuse_dentry->backing_path.dentry,
+ strlen(fa->in_args[1].value));
+ inode_unlock(dir_fuse_inode->backing_inode);
+
+ if (IS_ERR(backing_dentry))
+ return PTR_ERR(backing_dentry);
+
+ if (d_really_is_positive(backing_dentry)) {
+ err = -EIO;
+ goto out;
+ }
+
+ err = vfs_create(dir_fuse_inode->backing_inode, backing_dentry,
+ fci->mode, true);
+ if (err)
+ goto out;
+
+ if (get_fuse_dentry(entry)->backing_path.dentry)
+ path_put(&get_fuse_dentry(entry)->backing_path);
+ get_fuse_dentry(entry)->backing_path = (struct path) {
+ .mnt = dir_fuse_dentry->backing_path.mnt,
+ .dentry = backing_dentry,
+ };
+ path_get(&get_fuse_dentry(entry)->backing_path);
+
+ inode = fuse_iget_backing(dir->i_sb,
+ get_fuse_dentry(entry)->backing_path.dentry->d_inode);
+ if (IS_ERR(inode)) {
+ err = PTR_ERR(inode);
+ goto out;
+ }
+
+ if (get_fuse_inode(inode)->bpf)
+ bpf_prog_put(get_fuse_inode(inode)->bpf);
+ get_fuse_inode(inode)->bpf = dir_fuse_inode->bpf;
+ if (get_fuse_inode(inode)->bpf)
+ bpf_prog_inc(dir_fuse_inode->bpf);
+
+ newent = d_splice_alias(inode, entry);
+ if (IS_ERR(newent)) {
+ err = PTR_ERR(newent);
+ goto out;
+ }
+
+ entry = newent ? newent : entry;
+ err = finish_open(file, entry, fuse_open_file_backing);
+
+out:
+ dput(backing_dentry);
+ return err;
+}
+
+void *fuse_create_open_finalize(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry,
+ struct file *file, unsigned int flags, umode_t mode)
+{
+ struct fuse_file *ff = file->private_data;
+ struct fuse_inode *fi = get_fuse_inode(file->f_inode);
+ struct fuse_entry_out *feo = fa->out_args[0].value;
+ struct fuse_open_out *foo = fa->out_args[1].value;
+
+ fi->nodeid = feo->nodeid;
+ ff->fh = foo->fh;
+ return 0;
+}
+
+int fuse_release_initialize(struct fuse_args *fa, struct fuse_release_in *fri,
+ struct inode *inode, struct file *file)
+{
+ struct fuse_file *fuse_file = file->private_data;
+
+ /* Always put backing file whatever bpf/userspace says */
+ fput(fuse_file->backing_file);
+
+ *fri = (struct fuse_release_in) {
+ .fh = ((struct fuse_file *)(file->private_data))->fh,
+ };
+
+ *fa = (struct fuse_args) {
+ .nodeid = get_fuse_inode(inode)->nodeid,
+ .opcode = FUSE_RELEASE,
+ .in_numargs = 1,
+ .in_args[0].size = sizeof(*fri),
+ .in_args[0].value = fri,
+ };
+
+ return 0;
+}
+
+int fuse_releasedir_initialize(struct fuse_args *fa,
+ struct fuse_release_in *fri,
+ struct inode *inode, struct file *file)
+{
+ struct fuse_file *fuse_file = file->private_data;
+
+ /* Always put backing file whatever bpf/userspace says */
+ fput(fuse_file->backing_file);
+
+ *fri = (struct fuse_release_in) {
+ .fh = ((struct fuse_file *)(file->private_data))->fh,
+ };
+
+ *fa = (struct fuse_args) {
+ .nodeid = get_fuse_inode(inode)->nodeid,
+ .opcode = FUSE_RELEASEDIR,
+ .in_numargs = 1,
+ .in_args[0].size = sizeof(*fri),
+ .in_args[0].value = fri,
+ };
+
+ return 0;
+}
+
+int fuse_release_backing(struct fuse_args *fa,
+ struct inode *inode, struct file *file)
+{
+ return 0;
+}
+
+void *fuse_release_finalize(struct fuse_args *fa,
+ struct inode *inode, struct file *file)
+{
+ fuse_file_free(file->private_data);
+ return NULL;
+}
+
+int fuse_flush_initialize(struct fuse_args *fa, struct fuse_flush_in *ffi,
+ struct file *file, fl_owner_t id)
+{
+ struct fuse_file *fuse_file = file->private_data;
+
+ *ffi = (struct fuse_flush_in) {
+ .fh = fuse_file->fh,
+ };
+
+ *fa = (struct fuse_args) {
+ .nodeid = get_node_id(file->f_inode),
+ .opcode = FUSE_FLUSH,
+ .in_numargs = 1,
+ .in_args[0].size = sizeof(*ffi),
+ .in_args[0].value = ffi,
+ .force = true,
+ };
+
+ return 0;
+}
+
+int fuse_flush_backing(struct fuse_args *fa, struct file *file, fl_owner_t id)
+{
+ struct fuse_file *fuse_file = file->private_data;
+ struct file *backing_file = fuse_file->backing_file;
+
+ if (backing_file->f_op->flush)
+ return backing_file->f_op->flush(backing_file, id);
+ return 0;
+}
+
+void *fuse_flush_finalize(struct fuse_args *fa, struct file *file, fl_owner_t id)
+{
+ return NULL;
+}
+
+int fuse_fsync_initialize(struct fuse_args *fa, struct fuse_fsync_in *ffi,
+ struct file *file, loff_t start, loff_t end, int datasync)
+{
+ struct fuse_file *fuse_file = file->private_data;
+
+ *ffi = (struct fuse_fsync_in) {
+ .fh = fuse_file->fh,
+ .fsync_flags = datasync ? FUSE_FSYNC_FDATASYNC : 0,
+ };
+
+ *fa = (struct fuse_args) {
+ .nodeid = get_fuse_inode(file->f_inode)->nodeid,
+ .opcode = FUSE_FSYNC,
+ .in_numargs = 1,
+ .in_args[0].size = sizeof(*ffi),
+ .in_args[0].value = ffi,
+ .force = true,
+ };
+
+ return 0;
+}
+
+int fuse_fsync_backing(struct fuse_args *fa,
+ struct file *file, loff_t start, loff_t end, int datasync)
+{
+ struct fuse_file *fuse_file = file->private_data;
+ struct file *backing_file = fuse_file->backing_file;
+ const struct fuse_fsync_in *ffi = fa->in_args[0].value;
+ int new_datasync = (ffi->fsync_flags & FUSE_FSYNC_FDATASYNC) ? 1 : 0;
+
+ return vfs_fsync(backing_file, new_datasync);
+}
+
+void *fuse_fsync_finalize(struct fuse_args *fa,
+ struct file *file, loff_t start, loff_t end, int datasync)
+{
+ return NULL;
+}
+
+int fuse_dir_fsync_initialize(struct fuse_args *fa, struct fuse_fsync_in *ffi,
+ struct file *file, loff_t start, loff_t end, int datasync)
+{
+ struct fuse_file *fuse_file = file->private_data;
+
+ *ffi = (struct fuse_fsync_in) {
+ .fh = fuse_file->fh,
+ .fsync_flags = datasync ? FUSE_FSYNC_FDATASYNC : 0,
+ };
+
+ *fa = (struct fuse_args) {
+ .nodeid = get_fuse_inode(file->f_inode)->nodeid,
+ .opcode = FUSE_FSYNCDIR,
+ .in_numargs = 1,
+ .in_args[0].size = sizeof(*ffi),
+ .in_args[0].value = ffi,
+ .force = true,
+ };
+
+ return 0;
+}
+
+int fuse_getxattr_initialize(struct fuse_args *fa,
+ struct fuse_getxattr_io *fgio,
+ struct dentry *dentry, const char *name, void *value,
+ size_t size)
+{
+ *fgio = (struct fuse_getxattr_io) {
+ .fgi.size = size,
+ };
+
+ *fa = (struct fuse_args) {
+ .nodeid = get_fuse_inode(dentry->d_inode)->nodeid,
+ .opcode = FUSE_GETXATTR,
+ .in_numargs = 2,
+ .out_numargs = 1,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = sizeof(fgio->fgi),
+ .value = &fgio->fgi,
+ },
+ .in_args[1] = (struct fuse_in_arg) {
+ .size = strlen(name) + 1,
+ .value = name,
+ },
+ .out_argvar = size ? true : false,
+ .out_args[0].size = size ? size : sizeof(fgio->fgo),
+ .out_args[0].value = size ? value : &fgio->fgo,
+ };
+
+ return 0;
+}
+
+int fuse_getxattr_backing(struct fuse_args *fa,
+ struct dentry *dentry, const char *name, void *value,
+ size_t size)
+{
+ ssize_t ret = vfs_getxattr(get_fuse_dentry(dentry)->backing_path.dentry,
+ fa->in_args[1].value, value, size);
+
+ if (fa->out_argvar)
+ fa->out_args[0].size = ret;
+ else
+ ((struct fuse_getxattr_out *)fa->out_args[0].value)->size = ret;
+
+ return 0;
+}
+
+void *fuse_getxattr_finalize(struct fuse_args *fa,
+ struct dentry *dentry, const char *name, void *value,
+ size_t size)
+{
+ struct fuse_getxattr_out *fgo;
+
+ if (fa->out_argvar)
+ return ERR_PTR(fa->out_args[0].size);
+
+ fgo = fa->out_args[0].value;
+
+ return ERR_PTR(fgo->size);
+
+}
+
+int fuse_listxattr_initialize(struct fuse_args *fa,
+ struct fuse_getxattr_io *fgio,
+ struct dentry *dentry, char *list, size_t size)
+{
+ *fgio = (struct fuse_getxattr_io){
+ .fgi.size = size,
+ };
+
+ *fa = (struct fuse_args){
+ .nodeid = get_fuse_inode(dentry->d_inode)->nodeid,
+ .opcode = FUSE_LISTXATTR,
+ .in_numargs = 1,
+ .out_numargs = 1,
+ .in_args[0] =
+ (struct fuse_in_arg){
+ .size = sizeof(fgio->fgi),
+ .value = &fgio->fgi,
+ },
+ .out_argvar = size ? true : false,
+ .out_args[0].size = size ? size : sizeof(fgio->fgo),
+ .out_args[0].value = size ? (void *)list : &fgio->fgo,
+ };
+
+ return 0;
+}
+
+int fuse_listxattr_backing(struct fuse_args *fa, struct dentry *dentry,
+ char *list, size_t size)
+{
+ ssize_t ret =
+ vfs_listxattr(get_fuse_dentry(dentry)->backing_path.dentry,
+ list, size);
+
+ if (fa->out_argvar)
+ fa->out_args[0].size = ret;
+ else
+ ((struct fuse_getxattr_out *)fa->out_args[0].value)->size = ret;
+
+ return 0;
+}
+
+void *fuse_listxattr_finalize(struct fuse_args *fa, struct dentry *dentry,
+ char *list, size_t size)
+{
+ struct fuse_getxattr_out *fgo;
+
+ if (fa->out_argvar)
+ return ERR_PTR(fa->out_args[0].size);
+
+ fgo = fa->out_args[0].value;
+
+ return ERR_PTR(fgo->size);
+}
+
+int fuse_setxattr_initialize(struct fuse_args *fa,
+ struct fuse_setxattr_in *fsxi,
+ struct dentry *dentry, const char *name,
+ const void *value, size_t size, int flags)
+{
+ *fsxi = (struct fuse_setxattr_in) {
+ .size = size,
+ .flags = flags,
+ };
+
+ *fa = (struct fuse_args) {
+ .nodeid = get_fuse_inode(dentry->d_inode)->nodeid,
+ .opcode = FUSE_SETXATTR,
+ .in_numargs = 3,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = sizeof(*fsxi),
+ .value = fsxi,
+ },
+ .in_args[1] = (struct fuse_in_arg) {
+ .size = strlen(name) + 1,
+ .value = name,
+ },
+ .in_args[2] = (struct fuse_in_arg) {
+ .size = size,
+ .value = value,
+ },
+ };
+
+ return 0;
+}
+
+int fuse_setxattr_backing(struct fuse_args *fa, struct dentry *dentry,
+ const char *name, const void *value, size_t size,
+ int flags)
+{
+ return vfs_setxattr(get_fuse_dentry(dentry)->backing_path.dentry, name,
+ value, size, flags);
+}
+
+void *fuse_setxattr_finalize(struct fuse_args *fa, struct dentry *dentry,
+ const char *name, const void *value, size_t size,
+ int flags)
+{
+ return NULL;
+}
+
+int fuse_file_read_iter_initialize(
+ struct fuse_args *fa, struct fuse_read_in *fri,
+ struct kiocb *iocb, struct iov_iter *to)
+{
+ struct file *file = iocb->ki_filp;
+ struct fuse_file *ff = file->private_data;
+
+ *fri = (struct fuse_read_in) {
+ .fh = ff->fh,
+ .offset = iocb->ki_pos,
+ .size = to->count,
+ };
+
+ /* TODO we can't assume 'to' is a kvec */
+ /* TODO we also can't assume the vector has only one component */
+ *fa = (struct fuse_args) {
+ .opcode = FUSE_READ,
+ .nodeid = ff->nodeid,
+ .in_numargs = 1,
+ .in_args[0].size = sizeof(*fri),
+ .in_args[0].value = fri,
+ .out_numargs = 1,
+ .out_args[0].size = fri->size,
+ .out_args[0].value = to->kvec->iov_base,
+ /*
+ * TODO Design this properly.
+ * Possible approach: do not pass buf to bpf
+ * If going to userland, do a deep copy
+ * For extra credit, do that to/from the vector, rather than
+ * making an extra copy in the kernel
+ */
+ };
+
+ return 0;
+}
+
+int fuse_file_read_iter_backing(struct fuse_args *fa,
+ struct kiocb *iocb, struct iov_iter *to)
+{
+ struct file *file = iocb->ki_filp;
+ struct fuse_file *ff = file->private_data;
+ ssize_t result;
+
+ /* TODO This just plain ignores any change to fuse_read_in */
+ result = vfs_iter_read(ff->backing_file, to, &iocb->ki_pos, 0);
+
+ if (result < 0)
+ return result;
+
+ /* TODO Need to point value at the buffer for post-modification */
+ fa->out_args[0].size = result;
+ return result;
+}
+
+void *fuse_file_read_iter_finalize(struct fuse_args *fa,
+ struct kiocb *iocb, struct iov_iter *to)
+{
+ return ERR_PTR(fa->out_args[0].size);
+}
+
+int fuse_file_write_iter_initialize(
+ struct fuse_args *fa, struct fuse_file_write_iter_io *fwio,
+ struct kiocb *iocb, struct iov_iter *from)
+{
+ struct file *file = iocb->ki_filp;
+ struct fuse_file *ff = file->private_data;
+
+ *fwio = (struct fuse_file_write_iter_io) {
+ .fwi.fh = ff->fh,
+ .fwi.offset = iocb->ki_pos,
+ .fwi.size = from->count,
+ };
+
+ /* TODO we can't assume 'from' is a kvec */
+ *fa = (struct fuse_args) {
+ .opcode = FUSE_WRITE,
+ .nodeid = ff->nodeid,
+ .in_numargs = 2,
+ .in_args[0].size = sizeof(fwio->fwi),
+ .in_args[0].value = &fwio->fwi,
+ .in_args[1].size = fwio->fwi.size,
+ .in_args[1].value = from->kvec->iov_base,
+ .out_numargs = 1,
+ .out_args[0].size = sizeof(fwio->fwo),
+ .out_args[0].value = &fwio->fwo,
+ };
+
+ return 0;
+}
+
+int fuse_file_write_iter_backing(struct fuse_args *fa,
+ struct kiocb *iocb, struct iov_iter *from)
+{
+ struct file *file = iocb->ki_filp;
+ struct fuse_file *ff = file->private_data;
+ struct fuse_write_out *fwo = fa->out_args[0].value;
+
+ /* TODO This just plain ignores any change to fuse_write_in */
+ fwo->size = vfs_iter_write(ff->backing_file, from, &iocb->ki_pos, 0);
+
+ if (fwo->size < 0)
+ return fwo->size;
+ return 0;
+}
+
+void *fuse_file_write_iter_finalize(struct fuse_args *fa,
+ struct kiocb *iocb, struct iov_iter *from)
+{
+ struct fuse_write_out *fwo = fa->out_args[0].value;
+
+ return ERR_PTR(fwo->size);
+}
+
+int fuse_file_fallocate_initialize(struct fuse_args *fa,
+ struct fuse_fallocate_in *ffi,
+ struct file *file, int mode, loff_t offset, loff_t length)
+{
+ struct fuse_file *ff = file->private_data;
+
+ *ffi = (struct fuse_fallocate_in) {
+ .fh = ff->fh,
+ .offset = offset,
+ .length = length,
+ .mode = mode
+ };
+
+ *fa = (struct fuse_args) {
+ .opcode = FUSE_FALLOCATE,
+ .nodeid = ff->nodeid,
+ .in_numargs = 1,
+ .in_args[0].size = sizeof(*ffi),
+ .in_args[0].value = ffi,
+ };
+
+ return 0;
+}
+
+int fuse_file_fallocate_backing(struct fuse_args *fa,
+ struct file *file, int mode, loff_t offset, loff_t length)
+{
+ const struct fuse_fallocate_in *ffi = fa->in_args[0].value;
+ struct fuse_file *ff = file->private_data;
+
+ return vfs_fallocate(ff->backing_file, ffi->mode, ffi->offset,
+ ffi->length);
+}
+
+void *fuse_file_fallocate_finalize(struct fuse_args *fa,
+ struct file *file, int mode, loff_t offset, loff_t length)
+{
+ return NULL;
+}
+
+/*******************************************************************************
+ * Directory operations after here *
+ ******************************************************************************/
+
+int fuse_lookup_initialize(struct fuse_args *fa, struct fuse_lookup_io *fli,
+ struct inode *dir, struct dentry *entry, unsigned int flags)
+{
+ *fa = (struct fuse_args) {
+ .nodeid = get_fuse_inode(dir)->nodeid,
+ .opcode = FUSE_LOOKUP,
+ .in_numargs = 1,
+ .out_numargs = 2,
+ .out_argvar = 1,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = entry->d_name.len + 1,
+ .value = entry->d_name.name,
+ },
+ .out_args[0] = (struct fuse_arg) {
+ .size = sizeof(fli->feo),
+ .value = &fli->feo,
+ },
+ .out_args[1] = (struct fuse_arg) {
+ .size = sizeof(fli->febo),
+ .value = &fli->febo,
+ },
+ };
+
+ return 0;
+}
+
+int fuse_lookup_backing(struct fuse_args *fa, struct inode *dir,
+ struct dentry *entry, unsigned int flags)
+{
+ struct fuse_dentry *fuse_entry = get_fuse_dentry(entry);
+ struct fuse_dentry *dir_fuse_entry = get_fuse_dentry(entry->d_parent);
+ struct dentry *dir_backing_entry = dir_fuse_entry->backing_path.dentry;
+ struct inode *dir_backing_inode = dir_backing_entry->d_inode;
+ struct dentry *backing_entry;
+
+ /* TODO this will not handle lookups over mount points */
+ inode_lock_nested(dir_backing_inode, I_MUTEX_PARENT);
+ backing_entry = lookup_one_len(entry->d_name.name, dir_backing_entry,
+ strlen(entry->d_name.name));
+ inode_unlock(dir_backing_inode);
+
+ if (IS_ERR(backing_entry))
+ return PTR_ERR(backing_entry);
+
+ fuse_entry->backing_path = (struct path) {
+ .dentry = backing_entry,
+ .mnt = dir_fuse_entry->backing_path.mnt,
+ };
+
+ mntget(fuse_entry->backing_path.mnt);
+ return 0;
+}
+
+struct dentry *fuse_lookup_finalize(struct fuse_args *fa, struct inode *dir,
+ struct dentry *entry, unsigned int flags)
+{
+ struct fuse_dentry *fd;
+ struct dentry *bd;
+ struct inode *inode, *backing_inode;
+ struct fuse_entry_out *feo = fa->out_args[0].value;
+ struct fuse_entry_bpf_out *febo = fa->out_args[1].value;
+
+ fd = get_fuse_dentry(entry);
+ if (!fd)
+ return ERR_PTR(-EIO);
+ bd = fd->backing_path.dentry;
+ if (!bd)
+ return ERR_PTR(-ENOENT);
+ backing_inode = bd->d_inode;
+ if (!backing_inode)
+ return 0;
+
+ inode = fuse_iget_backing(dir->i_sb, backing_inode);
+
+ if (IS_ERR(inode))
+ return ERR_PTR(PTR_ERR(inode));
+
+ /* TODO Make sure this handles invalid handles */
+ /* TODO Do we need the same code in revalidate */
+ if (get_fuse_inode(inode)->bpf) {
+ bpf_prog_put(get_fuse_inode(inode)->bpf);
+ get_fuse_inode(inode)->bpf = NULL;
+ }
+
+ switch (febo->bpf_action) {
+ case FUSE_ACTION_KEEP:
+ get_fuse_inode(inode)->bpf = get_fuse_inode(dir)->bpf;
+ if (get_fuse_inode(inode)->bpf)
+ bpf_prog_inc(get_fuse_inode(inode)->bpf);
+ break;
+
+ case FUSE_ACTION_REMOVE:
+ get_fuse_inode(inode)->bpf = NULL;
+ break;
+
+ case FUSE_ACTION_REPLACE: {
+ struct fuse_conn *fc = get_fuse_mount(dir)->fc;
+ struct bpf_prog *bpf_prog = fuse_get_bpf_prog(fc, febo->bpf_fd);
+
+ if (IS_ERR(bpf_prog))
+ return ERR_PTR(PTR_ERR(bpf_prog));
+
+ get_fuse_inode(inode)->bpf = bpf_prog;
+ break;
+ }
+
+ default:
+ return ERR_PTR(-EIO);
+ }
+
+ switch (febo->backing_action) {
+ case FUSE_ACTION_KEEP:
+ /* backing inode/path are added in fuse_lookup_backing */
+ break;
+
+ case FUSE_ACTION_REMOVE:
+ iput(get_fuse_inode(inode)->backing_inode);
+ get_fuse_inode(inode)->backing_inode = NULL;
+ path_put_init(&get_fuse_dentry(entry)->backing_path);
+ break;
+
+ case FUSE_ACTION_REPLACE: {
+ struct fuse_conn *fc;
+ struct file *backing_file;
+
+ fc = get_fuse_mount(dir)->fc;
+ backing_file = fuse_fget(fc, febo->backing_fd);
+ if (!backing_file)
+ return ERR_PTR(-EIO);
+
+ iput(get_fuse_inode(inode)->backing_inode);
+ get_fuse_inode(inode)->backing_inode =
+ backing_file->f_inode;
+ ihold(get_fuse_inode(inode)->backing_inode);
+
+ path_put(&get_fuse_dentry(entry)->backing_path);
+ get_fuse_dentry(entry)->backing_path = backing_file->f_path;
+ path_get(&get_fuse_dentry(entry)->backing_path);
+
+ fput(backing_file);
+ break;
+ }
+
+ default:
+ return ERR_PTR(-EIO);
+ }
+
+ get_fuse_inode(inode)->nodeid = feo->nodeid;
+
+ return d_splice_alias(inode, entry);
+}
+
+int fuse_revalidate_backing(struct fuse_args *fa, struct inode *dir,
+ struct dentry *entry, unsigned int flags)
+{
+ struct fuse_dentry *fuse_dentry = get_fuse_dentry(entry);
+ struct dentry *backing_entry = fuse_dentry->backing_path.dentry;
+
+ if (unlikely(backing_entry->d_flags & DCACHE_OP_REVALIDATE))
+ return backing_entry->d_op->d_revalidate(backing_entry, flags);
+ return 1;
+}
+
+void *fuse_revalidate_finalize(struct fuse_args *fa, struct inode *dir,
+ struct dentry *entry, unsigned int flags)
+{
+ return 0;
+}
+
+int fuse_mknod_initialize(
+ struct fuse_args *fa, struct fuse_mknod_in *fmi,
+ struct inode *dir, struct dentry *entry, umode_t mode, dev_t rdev)
+{
+ *fmi = (struct fuse_mknod_in) {
+ .mode = mode,
+ .rdev = new_encode_dev(rdev),
+ .umask = current_umask(),
+ };
+ *fa = (struct fuse_args) {
+ .nodeid = get_node_id(dir),
+ .opcode = FUSE_MKNOD,
+ .in_numargs = 2,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = sizeof(*fmi),
+ .value = fmi,
+ },
+ .in_args[1] = (struct fuse_in_arg) {
+ .size = entry->d_name.len + 1,
+ .value = entry->d_name.name,
+ },
+ };
+
+ return 0;
+}
+
+int fuse_mknod_backing(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry, umode_t mode, dev_t rdev)
+{
+ int err = 0;
+ const struct fuse_mknod_in *fmi = fa->in_args[0].value;
+ struct inode *backing_inode = get_fuse_inode(dir)->backing_inode;
+ struct path backing_path = {};
+ struct inode *inode = NULL;
+
+ //TODO Actually deal with changing the backing entry in mknod
+ get_fuse_backing_path(entry, &backing_path);
+ if (!backing_path.dentry)
+ return -EBADF;
+
+ inode_lock_nested(backing_inode, I_MUTEX_PARENT);
+ err = vfs_mknod(backing_inode, backing_path.dentry,
+ fmi->mode & ~fmi->umask, new_decode_dev(fmi->rdev));
+ inode_unlock(backing_inode);
+ if (err)
+ goto out;
+ if (d_really_is_negative(backing_path.dentry) ||
+ unlikely(d_unhashed(backing_path.dentry))) {
+ err = -EINVAL;
+ /**
+ * TODO: overlayfs responds to this situation with a
+ * lookupOneLen. Should we do that too?
+ */
+ goto out;
+ }
+ inode = fuse_iget_backing(dir->i_sb, backing_inode);
+ if (IS_ERR(inode)) {
+ err = PTR_ERR(inode);
+ goto out;
+ }
+ d_instantiate(entry, inode);
+out:
+ path_put(&backing_path);
+ return err;
+}
+
+void *fuse_mknod_finalize(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry, umode_t mode, dev_t rdev)
+{
+ return NULL;
+}
+
+int fuse_mkdir_initialize(
+ struct fuse_args *fa, struct fuse_mkdir_in *fmi,
+ struct inode *dir, struct dentry *entry, umode_t mode)
+{
+ *fmi = (struct fuse_mkdir_in) {
+ .mode = mode,
+ .umask = current_umask(),
+ };
+ *fa = (struct fuse_args) {
+ .nodeid = get_node_id(dir),
+ .opcode = FUSE_MKDIR,
+ .in_numargs = 2,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = sizeof(*fmi),
+ .value = fmi,
+ },
+ .in_args[1] = (struct fuse_in_arg) {
+ .size = entry->d_name.len + 1,
+ .value = entry->d_name.name,
+ },
+ };
+
+ return 0;
+}
+
+int fuse_mkdir_backing(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry, umode_t mode)
+{
+ int err = 0;
+ const struct fuse_mkdir_in *fmi = fa->in_args[0].value;
+ struct inode *backing_inode = get_fuse_inode(dir)->backing_inode;
+ struct path backing_path = {};
+ struct inode *inode = NULL;
+
+ //TODO Actually deal with changing the backing entry in mkdir
+ get_fuse_backing_path(entry, &backing_path);
+ if (!backing_path.dentry)
+ return -EBADF;
+
+ inode_lock_nested(backing_inode, I_MUTEX_PARENT);
+ err = vfs_mkdir(backing_inode, backing_path.dentry, fmi->mode & ~fmi->umask);
+ inode_unlock(backing_inode);
+ if (err)
+ goto out;
+ if (d_really_is_negative(backing_path.dentry) ||
+ unlikely(d_unhashed(backing_path.dentry))) {
+ err = -EINVAL;
+ /**
+ * TODO: overlayfs responds to this situation with a
+ * lookupOneLen. Should we do that too?
+ */
+ goto out;
+ }
+ inode = fuse_iget_backing(dir->i_sb, backing_inode);
+ if (IS_ERR(inode)) {
+ err = PTR_ERR(inode);
+ goto out;
+ }
+ d_instantiate(entry, inode);
+out:
+ path_put(&backing_path);
+ return err;
+}
+
+void *fuse_mkdir_finalize(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry, umode_t mode)
+{
+ return NULL;
+}
+
+int fuse_rmdir_initialize(
+ struct fuse_args *fa, struct fuse_dummy_io *dummy,
+ struct inode *dir, struct dentry *entry)
+{
+ *fa = (struct fuse_args) {
+ .nodeid = get_node_id(dir),
+ .opcode = FUSE_RMDIR,
+ .in_numargs = 1,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = entry->d_name.len + 1,
+ .value = entry->d_name.name,
+ },
+ };
+
+ return 0;
+}
+
+int fuse_rmdir_backing(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry)
+{
+ int err = 0;
+ struct path backing_path = {};
+ struct dentry *backing_parent_dentry;
+ struct inode *backing_inode;
+
+ /* TODO Actually deal with changing the backing entry in rmdir */
+ get_fuse_backing_path(entry, &backing_path);
+ if (!backing_path.dentry)
+ return -EBADF;
+
+ /* TODO Not sure if we should reverify like overlayfs, or get inode from d_parent */
+ backing_parent_dentry = dget_parent(backing_path.dentry);
+ backing_inode = d_inode(backing_parent_dentry);
+
+ inode_lock_nested(backing_inode, I_MUTEX_PARENT);
+ err = vfs_rmdir(backing_inode, backing_path.dentry);
+ inode_unlock(backing_inode);
+
+ dput(backing_parent_dentry);
+ if (!err)
+ d_drop(entry);
+ path_put(&backing_path);
+ return err;
+}
+
+void *fuse_rmdir_finalize(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry)
+{
+ return NULL;
+}
+
+static int fuse_rename_backing_common(
+ struct inode *olddir, struct dentry *oldent,
+ struct inode *newdir, struct dentry *newent,
+ unsigned int flags)
+{
+ int err = 0;
+ struct path old_backing_path;
+ struct path new_backing_path;
+ struct dentry *old_backing_dir_dentry;
+ struct dentry *old_backing_dentry;
+ struct dentry *new_backing_dir_dentry;
+ struct dentry *new_backing_dentry;
+ struct dentry *trap = NULL;
+ struct inode *target_inode;
+
+ //TODO Actually deal with changing anything that isn't a flag
+ get_fuse_backing_path(oldent, &old_backing_path);
+ if (!old_backing_path.dentry)
+ return -EBADF;
+ get_fuse_backing_path(newent, &new_backing_path);
+ if (!new_backing_path.dentry) {
+ err = -EBADF;
+ goto put_old_path;
+ }
+ if (new_backing_path.mnt != old_backing_path.mnt) {
+ err = -EXDEV;
+ goto put_new_path;
+ }
+ old_backing_dentry = old_backing_path.dentry;
+ new_backing_dentry = new_backing_path.dentry;
+ old_backing_dir_dentry = dget_parent(old_backing_dentry);
+ new_backing_dir_dentry = dget_parent(new_backing_dentry);
+ target_inode = d_inode(newent);
+
+ trap = lock_rename(old_backing_dir_dentry, new_backing_dir_dentry);
+ if (trap == old_backing_dentry) {
+ err = -EINVAL;
+ goto put_parents;
+ }
+ if (trap == new_backing_dentry) {
+ err = -ENOTEMPTY;
+ goto put_parents;
+ }
+ err = vfs_rename(d_inode(old_backing_dir_dentry), old_backing_dentry,
+ d_inode(new_backing_dir_dentry), new_backing_dentry,
+ NULL, flags);
+ if (err)
+ goto unlock;
+ if (target_inode)
+ fsstack_copy_attr_all(target_inode,
+ get_fuse_inode(target_inode)->backing_inode);
+ fsstack_copy_attr_all(newdir, d_inode(new_backing_dir_dentry));
+unlock:
+ unlock_rename(old_backing_dir_dentry, new_backing_dir_dentry);
+put_parents:
+ dput(new_backing_dir_dentry);
+ dput(old_backing_dir_dentry);
+put_new_path:
+ path_put(&new_backing_path);
+put_old_path:
+ path_put(&old_backing_path);
+ return err;
+}
+
+int fuse_rename2_initialize(struct fuse_args *fa, struct fuse_rename2_in *fri,
+ struct inode *olddir, struct dentry *oldent,
+ struct inode *newdir, struct dentry *newent,
+ unsigned int flags)
+{
+ *fri = (struct fuse_rename2_in) {
+ .newdir = get_node_id(newdir),
+ .flags = flags,
+ };
+ *fa = (struct fuse_args) {
+ .nodeid = get_node_id(olddir),
+ .opcode = FUSE_RENAME2,
+ .in_numargs = 3,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = sizeof(*fri),
+ .value = fri,
+ },
+ .in_args[1] = (struct fuse_in_arg) {
+ .size = oldent->d_name.len + 1,
+ .value = oldent->d_name.name,
+ },
+ .in_args[2] = (struct fuse_in_arg) {
+ .size = newent->d_name.len + 1,
+ .value = newent->d_name.name,
+ },
+ };
+
+ return 0;
+}
+
+int fuse_rename2_backing(struct fuse_args *fa,
+ struct inode *olddir, struct dentry *oldent,
+ struct inode *newdir, struct dentry *newent,
+ unsigned int flags)
+{
+ const struct fuse_rename2_in *fri = fa->in_args[0].value;
+
+ /* TODO: deal with changing dirs/ents */
+ return fuse_rename_backing_common(olddir, oldent, newdir, newent, fri->flags);
+}
+
+void *fuse_rename2_finalize(struct fuse_args *fa,
+ struct inode *olddir, struct dentry *oldent,
+ struct inode *newdir, struct dentry *newent,
+ unsigned int flags)
+{
+ return NULL;
+}
+
+int fuse_rename_initialize(struct fuse_args *fa, struct fuse_rename_in *fri,
+ struct inode *olddir, struct dentry *oldent,
+ struct inode *newdir, struct dentry *newent)
+{
+ *fri = (struct fuse_rename_in) {
+ .newdir = get_node_id(newdir),
+ };
+ *fa = (struct fuse_args) {
+ .nodeid = get_node_id(olddir),
+ .opcode = FUSE_RENAME,
+ .in_numargs = 3,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = sizeof(*fri),
+ .value = fri,
+ },
+ .in_args[1] = (struct fuse_in_arg) {
+ .size = oldent->d_name.len + 1,
+ .value = oldent->d_name.name,
+ },
+ .in_args[2] = (struct fuse_in_arg) {
+ .size = newent->d_name.len + 1,
+ .value = newent->d_name.name,
+ },
+ };
+
+ return 0;
+}
+
+int fuse_rename_backing(struct fuse_args *fa,
+ struct inode *olddir, struct dentry *oldent,
+ struct inode *newdir, struct dentry *newent)
+{
+ /* TODO: deal with changing dirs/ents */
+ return fuse_rename_backing_common(olddir, oldent, newdir, newent, 0);
+}
+
+void *fuse_rename_finalize(struct fuse_args *fa,
+ struct inode *olddir, struct dentry *oldent,
+ struct inode *newdir, struct dentry *newent)
+{
+ return NULL;
+}
+
+int fuse_unlink_initialize(
+ struct fuse_args *fa, struct fuse_dummy_io *dummy,
+ struct inode *dir, struct dentry *entry)
+{
+ *fa = (struct fuse_args) {
+ .nodeid = get_node_id(dir),
+ .opcode = FUSE_UNLINK,
+ .in_numargs = 1,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = entry->d_name.len + 1,
+ .value = entry->d_name.name,
+ },
+ };
+
+ return 0;
+}
+
+int fuse_unlink_backing(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry)
+{
+ int err = 0;
+ struct path backing_path = {};
+ struct dentry *backing_parent_dentry;
+ struct inode *backing_inode;
+
+ /* TODO Actually deal with changing the backing entry in unlink */
+ get_fuse_backing_path(entry, &backing_path);
+ if (!backing_path.dentry)
+ return -EBADF;
+
+ /* TODO Not sure if we should reverify like overlayfs, or get inode from d_parent */
+ backing_parent_dentry = dget_parent(backing_path.dentry);
+ backing_inode = d_inode(backing_parent_dentry);
+
+ inode_lock_nested(backing_inode, I_MUTEX_PARENT);
+ err = vfs_unlink(backing_inode, backing_path.dentry, NULL);
+ inode_unlock(backing_inode);
+
+ dput(backing_parent_dentry);
+ if (!err)
+ d_drop(entry);
+ path_put(&backing_path);
+ return err;
+}
+
+void *fuse_unlink_finalize(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry)
+{
+ return NULL;
+}
+
+int fuse_link_initialize(struct fuse_args *fa, struct fuse_link_in *fli,
+ struct dentry *entry, struct inode *dir,
+ struct dentry *newent)
+{
+ struct inode *src_inode = entry->d_inode;
+
+ *fli = (struct fuse_link_in){
+ .oldnodeid = get_node_id(src_inode),
+ };
+
+ fa->opcode = FUSE_LINK;
+ fa->in_numargs = 2;
+ fa->in_args[0].size = sizeof(*fli);
+ fa->in_args[0].value = fli;
+ fa->in_args[1].size = newent->d_name.len + 1;
+ fa->in_args[1].value = newent->d_name.name;
+
+ return 0;
+}
+
+int fuse_link_backing(struct fuse_args *fa, struct dentry *entry,
+ struct inode *dir, struct dentry *newent)
+{
+ int err = 0;
+ struct path backing_old_path = {};
+ struct path backing_new_path = {};
+ struct dentry *backing_dir_dentry;
+ struct inode *fuse_new_inode = NULL;
+ struct inode *backing_dir_inode = get_fuse_inode(dir)->backing_inode;
+
+ get_fuse_backing_path(entry, &backing_old_path);
+ if (!backing_old_path.dentry)
+ return -EBADF;
+
+ get_fuse_backing_path(newent, &backing_new_path);
+ if (!backing_new_path.dentry) {
+ err = -EBADF;
+ goto err_dst_path;
+ }
+
+ backing_dir_dentry = dget_parent(backing_new_path.dentry);
+ backing_dir_inode = d_inode(backing_dir_dentry);
+
+ inode_lock_nested(backing_dir_inode, I_MUTEX_PARENT);
+ err = vfs_link(backing_old_path.dentry, backing_dir_inode, backing_new_path.dentry, NULL);
+ inode_unlock(backing_dir_inode);
+ if (err)
+ goto out;
+
+ if (d_really_is_negative(backing_new_path.dentry) ||
+ unlikely(d_unhashed(backing_new_path.dentry))) {
+ err = -EINVAL;
+ /**
+ * TODO: overlayfs responds to this situation with a
+ * lookupOneLen. Should we do that too?
+ */
+ goto out;
+ }
+
+ fuse_new_inode = fuse_iget_backing(dir->i_sb, backing_dir_inode);
+ if (IS_ERR(fuse_new_inode)) {
+ err = PTR_ERR(fuse_new_inode);
+ goto out;
+ }
+ d_instantiate(newent, fuse_new_inode);
+
+out:
+ dput(backing_dir_dentry);
+ path_put(&backing_new_path);
+err_dst_path:
+ path_put(&backing_old_path);
+ return err;
+}
+
+void *fuse_link_finalize(struct fuse_args *fa, struct dentry *entry,
+ struct inode *dir, struct dentry *newent)
+{
+ return NULL;
+}
+
+int fuse_getattr_initialize(struct fuse_args *fa, struct fuse_getattr_io *fgio,
+ const struct dentry *entry, struct kstat *stat,
+ u32 request_mask, unsigned int flags)
+{
+ fgio->fgi = (struct fuse_getattr_in) {
+ .getattr_flags = flags,
+ .fh = -1, /* TODO is this OK? */
+ };
+
+ fgio->fao = (struct fuse_attr_out) {0};
+
+ *fa = (struct fuse_args) {
+ .nodeid = get_node_id(entry->d_inode),
+ .opcode = FUSE_GETATTR,
+ .in_numargs = 1,
+ .out_numargs = 1,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = sizeof(fgio->fgi),
+ .value = &fgio->fgi,
+ },
+ .out_args[0] = (struct fuse_arg) {
+ .size = sizeof(fgio->fao),
+ .value = &fgio->fao,
+ },
+ };
+
+ return 0;
+}
+
+static void fuse_stat_to_attr(struct fuse_conn *fc, struct inode *inode,
+ struct kstat *stat, struct fuse_attr *attr)
+{
+ unsigned int blkbits;
+
+ /* see the comment in fuse_change_attributes() */
+ if (fc->writeback_cache && S_ISREG(inode->i_mode)) {
+ stat->size = i_size_read(inode);
+ stat->mtime.tv_sec = inode->i_mtime.tv_sec;
+ stat->mtime.tv_nsec = inode->i_mtime.tv_nsec;
+ stat->ctime.tv_sec = inode->i_ctime.tv_sec;
+ stat->ctime.tv_nsec = inode->i_ctime.tv_nsec;
+ }
+
+ attr->ino = stat->ino;
+ attr->mode = (inode->i_mode & S_IFMT) | (stat->mode & 07777);
+ attr->nlink = stat->nlink;
+ attr->uid = from_kuid(fc->user_ns, stat->uid);
+ attr->gid = from_kgid(fc->user_ns, stat->gid);
+ attr->atime = stat->atime.tv_sec;
+ attr->atimensec = stat->atime.tv_nsec;
+ attr->mtime = stat->mtime.tv_sec;
+ attr->mtimensec = stat->mtime.tv_nsec;
+ attr->ctime = stat->ctime.tv_sec;
+ attr->ctimensec = stat->ctime.tv_nsec;
+ attr->size = stat->size;
+ attr->blocks = stat->blocks;
+
+ if (stat->blksize != 0)
+ blkbits = ilog2(stat->blksize);
+ else
+ blkbits = inode->i_sb->s_blocksize_bits;
+
+ attr->blksize = 1 << blkbits;
+}
+
+int fuse_getattr_backing(struct fuse_args *fa,
+ const struct dentry *entry, struct kstat *stat,
+ u32 request_mask, unsigned int flags)
+{
+ struct path *backing_path =
+ &get_fuse_dentry(entry)->backing_path;
+ struct inode *backing_inode = backing_path->dentry->d_inode;
+ struct fuse_attr_out *fao = fa->out_args[0].value;
+ struct kstat tmp;
+ int err;
+
+ if (!stat)
+ stat = &tmp;
+
+ err = vfs_getattr(backing_path, stat, request_mask, flags);
+
+ if (!err)
+ fuse_stat_to_attr(get_fuse_conn(entry->d_inode),
+ backing_inode, stat, &fao->attr);
+
+ return err;
+}
+
+void *fuse_getattr_finalize(struct fuse_args *fa,
+ const struct dentry *entry, struct kstat *stat,
+ u32 request_mask, unsigned int flags)
+{
+ struct fuse_attr_out *outarg = fa->out_args[0].value;
+ struct inode *inode = entry->d_inode;
+ u64 attr_version = fuse_get_attr_version(get_fuse_mount(inode)->fc);
+ int err = 0;
+
+ /* TODO: Ensure this doesn't happen if we had an error getting attrs in
+ * backing.
+ */
+ err = finalize_attr(inode, outarg, attr_version, stat);
+ return ERR_PTR(err);
+}
+
+static void fattr_to_iattr(const struct fuse_setattr_in *arg,
+ struct iattr *iattr)
+{
+ unsigned int ivalid = arg->valid;
+
+ if (ivalid & ATTR_MODE)
+ iattr->ia_valid |= FATTR_MODE, iattr->ia_mode = arg->mode;
+ if (ivalid & ATTR_UID) {
+ iattr->ia_valid |= FATTR_UID;
+ iattr->ia_uid = KUIDT_INIT(arg->uid);
+ }
+ if (ivalid & ATTR_GID) {
+ iattr->ia_valid |= FATTR_GID;
+ iattr->ia_gid = KGIDT_INIT(arg->gid);
+ }
+ if (ivalid & ATTR_SIZE)
+ iattr->ia_valid |= FATTR_SIZE, iattr->ia_size = arg->size;
+ if (ivalid & ATTR_ATIME) {
+ iattr->ia_valid |= FATTR_ATIME;
+ iattr->ia_atime.tv_sec = arg->atime;
+ iattr->ia_atime.tv_nsec = arg->atimensec;
+ if (!(ivalid & ATTR_ATIME_SET))
+ iattr->ia_valid |= FATTR_ATIME_NOW;
+ }
+ if (ivalid & ATTR_MTIME) {
+ iattr->ia_valid |= FATTR_MTIME;
+ iattr->ia_mtime.tv_sec = arg->mtime;
+ iattr->ia_mtime.tv_nsec = arg->mtimensec;
+ }
+ if (ivalid & ATTR_CTIME) {
+ iattr->ia_valid |= FATTR_CTIME;
+ iattr->ia_ctime.tv_sec = arg->ctime;
+ iattr->ia_ctime.tv_nsec = arg->ctimensec;
+ }
+}
+
+int fuse_setattr_initialize(struct fuse_args *fa, struct fuse_setattr_io *fsio,
+ struct dentry *dentry, struct iattr *attr, struct file *file)
+{
+ struct fuse_conn *fc = get_fuse_conn(dentry->d_inode);
+
+ *fsio = (struct fuse_setattr_io) {0};
+ iattr_to_fattr(fc, attr, &fsio->fsi, true);
+
+ *fa = (struct fuse_args) {
+ .opcode = FUSE_SETATTR,
+ .nodeid = get_node_id(dentry->d_inode),
+ .in_numargs = 1,
+ .in_args[0].size = sizeof(fsio->fsi),
+ .in_args[0].value = &fsio->fsi,
+ .out_numargs = 1,
+ .out_args[0].size = sizeof(fsio->fao),
+ .out_args[0].value = &fsio->fao,
+ };
+
+ return 0;
+}
+
+int fuse_setattr_backing(struct fuse_args *fa,
+ struct dentry *dentry, struct iattr *attr, struct file *file)
+{
+ const struct fuse_setattr_in *fsi = fa->in_args[0].value;
+ struct iattr new_attr = {0};
+ struct path *backing_path = &get_fuse_dentry(dentry)->backing_path;
+ int res;
+
+ fattr_to_iattr(fsi, &new_attr);
+ inode_lock(d_inode(backing_path->dentry));
+ res = notify_change(backing_path->dentry, &new_attr, NULL);
+ inode_unlock(d_inode(backing_path->dentry));
+ return res;
+}
+
+void *fuse_setattr_finalize(struct fuse_args *fa,
+ struct dentry *dentry, struct iattr *attr, struct file *file)
+{
+ return NULL;
+}
+
+int fuse_get_link_initialize(struct fuse_args *fa, struct fuse_dummy_io *unused,
+ struct inode *inode, struct dentry *dentry,
+ struct delayed_call *callback, const char **out)
+{
+ /*
+ * TODO
+ * If we want to handle changing these things, we'll need to copy
+ * the lower fs's data into our own buffer, and provide our own callback
+ * to free that buffer.
+ *
+ * Pre could change the name we're looking at
+ * postfilter can change the name we return
+ *
+ * We ought to only make that buffer if it's been requested, so leaving
+ * this unimplemented for the moment
+ */
+ *fa = (struct fuse_args) {
+ .opcode = FUSE_READLINK,
+ .nodeid = get_node_id(inode),
+ .in_numargs = 1,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = dentry->d_name.len + 1,
+ .value = dentry->d_name.name,
+ },
+ /*
+ * .out_argvar = 1,
+ * .out_numargs = 1,
+ * .out_args[0].size = ,
+ * .out_args[0].value = ,
+ */
+ };
+
+ return 0;
+}
+
+int fuse_get_link_backing(struct fuse_args *fa,
+ struct inode *inode, struct dentry *dentry,
+ struct delayed_call *callback, const char **out)
+{
+ struct path backing_path;
+
+ if (!dentry) {
+ *out = ERR_PTR(-ECHILD);
+ return PTR_ERR(*out);
+ }
+
+ get_fuse_backing_path(dentry, &backing_path);
+ if (!backing_path.dentry) {
+ *out = ERR_PTR(-ECHILD);
+ return PTR_ERR(*out);
+ }
+
+ /*
+ * TODO: If we want to do our own thing, copy the data and then call the
+ * callback
+ */
+ *out = vfs_get_link(backing_path.dentry, callback);
+
+ path_put(&backing_path);
+ return 0;
+}
+
+void *fuse_get_link_finalize(struct fuse_args *fa,
+ struct inode *inode, struct dentry *dentry,
+ struct delayed_call *callback, const char **out)
+{
+ return NULL;
+}
+
+int fuse_symlink_initialize(
+ struct fuse_args *fa, struct fuse_dummy_io *unused,
+ struct inode *dir, struct dentry *entry, const char *link, int len)
+{
+ *fa = (struct fuse_args) {
+ .nodeid = get_node_id(dir),
+ .opcode = FUSE_SYMLINK,
+ .in_numargs = 2,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = entry->d_name.len + 1,
+ .value = entry->d_name.name,
+ },
+ .in_args[1] = (struct fuse_in_arg) {
+ .size = len,
+ .value = link,
+ },
+ };
+
+ return 0;
+}
+
+int fuse_symlink_backing(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry, const char *link, int len)
+{
+ int err = 0;
+ struct inode *backing_inode = get_fuse_inode(dir)->backing_inode;
+ struct path backing_path = {};
+ struct inode *inode = NULL;
+
+ //TODO Actually deal with changing the backing entry in symlink
+ get_fuse_backing_path(entry, &backing_path);
+ if (!backing_path.dentry)
+ return -EBADF;
+
+ inode_lock_nested(backing_inode, I_MUTEX_PARENT);
+ err = vfs_symlink(backing_inode, backing_path.dentry, link);
+ inode_unlock(backing_inode);
+ if (err)
+ goto out;
+ if (d_really_is_negative(backing_path.dentry) ||
+ unlikely(d_unhashed(backing_path.dentry))) {
+ err = -EINVAL;
+ /**
+ * TODO: overlayfs responds to this situation with a
+ * lookupOneLen. Should we do that too?
+ */
+ goto out;
+ }
+ inode = fuse_iget_backing(dir->i_sb, backing_inode);
+ if (IS_ERR(inode)) {
+ err = PTR_ERR(inode);
+ goto out;
+ }
+ d_instantiate(entry, inode);
+out:
+ path_put(&backing_path);
+ return err;
+}
+
+void *fuse_symlink_finalize(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry, const char *link, int len)
+{
+ return NULL;
+}
+
+int fuse_readdir_initialize(struct fuse_args *fa, struct fuse_read_io *frio,
+ struct file *file, struct dir_context *ctx,
+ bool *force_again, bool *allow_force)
+{
+ struct fuse_file *ff = file->private_data;
+ u8 *page = (u8 *)__get_free_page(GFP_KERNEL);
+
+ if (!page)
+ return -ENOMEM;
+
+ *fa = (struct fuse_args) {
+ .nodeid = ff->nodeid,
+ .opcode = FUSE_READDIR,
+ .in_numargs = 1,
+ .out_argvar = true,
+ .out_numargs = 2,
+ .in_args[0] = (struct fuse_in_arg) {
+ .size = sizeof(frio->fri),
+ .value = &frio->fri,
+ },
+ .out_args[0] = (struct fuse_arg) {
+ .size = sizeof(frio->fro),
+ .value = &frio->fro,
+ },
+ .out_args[1] = (struct fuse_arg) {
+ .size = PAGE_SIZE,
+ .value = page,
+ },
+ };
+
+ frio->fri = (struct fuse_read_in) {
+ .fh = ff->fh,
+ .offset = ctx->pos,
+ .size = PAGE_SIZE,
+ };
+ frio->fro = (struct fuse_read_out) {
+ .again = 0,
+ .offset = 0,
+ };
+ *force_again = false;
+ *allow_force = true;
+ return 0;
+}
+
+struct extfuse_ctx {
+ struct dir_context ctx;
+ u8 *addr;
+ size_t offset;
+};
+
+static int filldir(struct dir_context *ctx, const char *name, int namelen,
+ loff_t offset, u64 ino, unsigned int d_type)
+{
+ struct extfuse_ctx *ec = container_of(ctx, struct extfuse_ctx, ctx);
+ struct fuse_dirent *fd = (struct fuse_dirent *) (ec->addr + ec->offset);
+
+ if (ec->offset + sizeof(struct fuse_dirent) + namelen > PAGE_SIZE)
+ return -ENOMEM;
+
+ *fd = (struct fuse_dirent) {
+ .ino = ino,
+ .off = offset,
+ .namelen = namelen,
+ .type = d_type,
+ };
+
+ strcpy(fd->name, name);
+ ec->offset += FUSE_DIRENT_SIZE(fd);
+
+ return 0;
+}
+
+int fuse_readdir_backing(struct fuse_args *fa,
+ struct file *file, struct dir_context *ctx,
+ bool *force_again, bool *allow_force)
+{
+ struct fuse_file *ff = file->private_data;
+ struct file *backing_dir = ff->backing_file;
+ struct fuse_read_out *fro = fa->out_args[0].value;
+ struct extfuse_ctx ec;
+ int err;
+
+ ec = (struct extfuse_ctx) {
+ .ctx.actor = filldir,
+ .ctx.pos = ctx->pos,
+ .addr = fa->out_args[1].value,
+ };
+
+ if (!ec.addr)
+ return -ENOMEM;
+
+ err = iterate_dir(backing_dir, &ec.ctx);
+ if (ec.offset == 0)
+ *allow_force = false;
+ fa->out_args[1].size = ec.offset;
+
+ fro->offset = ec.ctx.pos;
+ fro->again = false;
+ return err;
+}
+
+void *fuse_readdir_finalize(struct fuse_args *fa,
+ struct file *file, struct dir_context *ctx,
+ bool *force_again, bool *allow_force)
+{
+ int err = 0;
+ struct fuse_file *ff = file->private_data;
+ struct file *backing_dir = ff->backing_file;
+ struct fuse_read_out *fro = fa->out_args[0].value;
+
+ err = fuse_parse_dirfile(fa->out_args[1].value,
+ fa->out_args[1].size, file, ctx);
+ *force_again = !!fro->again;
+ if (*force_again && !*allow_force)
+ err = -EINVAL;
+ backing_dir->f_pos = fro->offset;
+
+ free_page((unsigned long) fa->out_args[1].value);
+ return ERR_PTR(err);
+}
+
+int fuse_access_initialize(struct fuse_args *fa, struct fuse_access_in *fai,
+ struct inode *inode, int mask)
+{
+ *fai = (struct fuse_access_in) {
+ .mask = mask,
+ };
+
+ *fa = (struct fuse_args) {
+ .opcode = FUSE_ACCESS,
+ .nodeid = get_node_id(inode),
+ .in_numargs = 1,
+ .in_args[0].size = sizeof(*fai),
+ .in_args[0].value = fai,
+ };
+
+ return 0;
+}
+
+int fuse_access_backing(struct fuse_args *fa, struct inode *inode, int mask)
+{
+ struct fuse_inode *fi = get_fuse_inode(inode);
+ const struct fuse_access_in *fai = fa->in_args[0].value;
+
+ return inode_permission(/* For mainline: init_user_ns,*/
+ fi->backing_inode, fai->mask);
+}
+
+void *fuse_access_finalize(struct fuse_args *fa, struct inode *inode, int mask)
+{
+ return NULL;
+}
diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index c93b015..0085728 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -239,6 +239,11 @@
{
struct fuse_iqueue *fiq = &fc->iq;
+ if (nodeid == 0) {
+ kfree(forget);
+ return;
+ }
+
forget->forget_one.nodeid = nodeid;
forget->forget_one.nlookup = nlookup;
@@ -480,6 +485,7 @@
{
req->in.h.opcode = args->opcode;
req->in.h.nodeid = args->nodeid;
+ req->in.h.error_in = args->error_in;
req->args = args;
if (args->end)
__set_bit(FR_ASYNC, &req->flags);
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index f2a48918..62f9ac4 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -8,8 +8,10 @@
#include "fuse_i.h"
+#include <linux/fdtable.h>
#include <linux/pagemap.h>
#include <linux/file.h>
+#include <linux/filter.h>
#include <linux/fs_context.h>
#include <linux/sched.h>
#include <linux/namei.h>
@@ -18,6 +20,8 @@
#include <linux/iversion.h>
#include <linux/posix_acl.h>
+#include "../internal.h"
+
static void fuse_advise_use_readdirplus(struct inode *dir)
{
struct fuse_inode *fi = get_fuse_inode(dir);
@@ -25,7 +29,7 @@
set_bit(FUSE_I_ADVISE_RDPLUS, &fi->state);
}
-#if BITS_PER_LONG >= 64
+#if BITS_PER_LONG >= 64 && !defined(CONFIG_FUSE_BPF)
static inline void __fuse_dentry_settime(struct dentry *entry, u64 time)
{
entry->d_fsdata = (void *) time;
@@ -37,19 +41,15 @@
}
#else
-union fuse_dentry {
- u64 time;
- struct rcu_head rcu;
-};
static inline void __fuse_dentry_settime(struct dentry *dentry, u64 time)
{
- ((union fuse_dentry *) dentry->d_fsdata)->time = time;
+ ((struct fuse_dentry *) dentry->d_fsdata)->time = time;
}
static inline u64 fuse_dentry_time(const struct dentry *entry)
{
- return ((union fuse_dentry *) entry->d_fsdata)->time;
+ return ((struct fuse_dentry *) entry->d_fsdata)->time;
}
#endif
@@ -74,6 +74,18 @@
__fuse_dentry_settime(dentry, time);
}
+void fuse_init_dentry_root(struct dentry *root, struct file *backing_dir)
+{
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_dentry *fuse_dentry = root->d_fsdata;
+
+ if (backing_dir) {
+ fuse_dentry->backing_path = backing_dir->f_path;
+ path_get(&fuse_dentry->backing_path);
+ }
+#endif
+}
+
/*
* Set dentry and possibly attribute timeouts from the lookup/mk*
* replies
@@ -144,7 +156,8 @@
static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_args *args,
u64 nodeid, const struct qstr *name,
- struct fuse_entry_out *outarg)
+ struct fuse_entry_out *outarg,
+ struct fuse_entry_bpf_out *bpf_outarg)
{
memset(outarg, 0, sizeof(struct fuse_entry_out));
args->opcode = FUSE_LOOKUP;
@@ -152,9 +165,12 @@
args->in_numargs = 1;
args->in_args[0].size = name->len + 1;
args->in_args[0].value = name->name;
- args->out_numargs = 1;
+ args->out_argvar = true;
+ args->out_numargs = 2;
args->out_args[0].size = sizeof(struct fuse_entry_out);
args->out_args[0].value = outarg;
+ args->out_args[1].size = sizeof(struct fuse_entry_bpf_out);
+ args->out_args[1].value = bpf_outarg;
}
/*
@@ -180,6 +196,7 @@
else if (time_before64(fuse_dentry_time(entry), get_jiffies_64()) ||
(flags & LOOKUP_REVAL)) {
struct fuse_entry_out outarg;
+ struct fuse_entry_bpf_out bpf_outarg;
FUSE_ARGS(args);
struct fuse_forget_link *forget;
u64 attr_version;
@@ -191,7 +208,20 @@
ret = -ECHILD;
if (flags & LOOKUP_RCU)
goto out;
+#ifdef CONFIG_FUSE_BPF
+ {
+ struct fuse_err_ret fer;
+ fer = fuse_bpf_backing(entry->d_parent->d_inode,
+ struct fuse_lookup_io,
+ fuse_lookup_initialize,
+ fuse_revalidate_backing,
+ fuse_revalidate_finalize,
+ d_inode(entry->d_parent), entry, flags);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+ }
+#endif
fm = get_fuse_mount(inode);
forget = fuse_alloc_forget();
@@ -202,8 +232,9 @@
attr_version = fuse_get_attr_version(fm->fc);
parent = dget_parent(entry);
+
fuse_lookup_init(fm->fc, &args, get_node_id(d_inode(parent)),
- &entry->d_name, &outarg);
+ &entry->d_name, &outarg, &bpf_outarg);
ret = fuse_simple_request(fm, &args);
dput(parent);
/* Zero nodeid is same as -ENOENT */
@@ -253,17 +284,20 @@
goto out;
}
-#if BITS_PER_LONG < 64
+#if BITS_PER_LONG < 64 || defined(CONFIG_FUSE_BPF)
static int fuse_dentry_init(struct dentry *dentry)
{
- dentry->d_fsdata = kzalloc(sizeof(union fuse_dentry),
+ dentry->d_fsdata = kzalloc(sizeof(struct fuse_dentry),
GFP_KERNEL_ACCOUNT | __GFP_RECLAIMABLE);
return dentry->d_fsdata ? 0 : -ENOMEM;
}
static void fuse_dentry_release(struct dentry *dentry)
{
- union fuse_dentry *fd = dentry->d_fsdata;
+ struct fuse_dentry *fd = dentry->d_fsdata;
+
+ if (fd && fd->backing_path.dentry)
+ path_put(&fd->backing_path);
kfree_rcu(fd, rcu);
}
@@ -404,7 +438,7 @@
const struct dentry_operations fuse_dentry_operations = {
.d_revalidate = fuse_dentry_revalidate,
.d_delete = fuse_dentry_delete,
-#if BITS_PER_LONG < 64
+#if BITS_PER_LONG < 64 || defined(CONFIG_FUSE_BPF)
.d_init = fuse_dentry_init,
.d_release = fuse_dentry_release,
#endif
@@ -413,7 +447,7 @@
};
const struct dentry_operations fuse_root_dentry_operations = {
-#if BITS_PER_LONG < 64
+#if BITS_PER_LONG < 64 || defined(CONFIG_FUSE_BPF)
.d_init = fuse_dentry_init,
.d_release = fuse_dentry_release,
#endif
@@ -432,7 +466,10 @@
}
int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name,
- struct fuse_entry_out *outarg, struct inode **inode)
+ struct fuse_entry_out *outarg,
+ struct fuse_entry_bpf_out *bpf_outarg,
+ struct dentry *entry,
+ struct inode **inode)
{
struct fuse_mount *fm = get_fuse_mount_super(sb);
FUSE_ARGS(args);
@@ -453,23 +490,82 @@
attr_version = fuse_get_attr_version(fm->fc);
- fuse_lookup_init(fm->fc, &args, nodeid, name, outarg);
+ fuse_lookup_init(fm->fc, &args, nodeid, name, outarg, bpf_outarg);
err = fuse_simple_request(fm, &args);
- /* Zero nodeid is same as -ENOENT, but with valid timeout */
- if (err || !outarg->nodeid)
- goto out_put_forget;
- err = -EIO;
- if (!outarg->nodeid)
- goto out_put_forget;
- if (fuse_invalid_attr(&outarg->attr))
- goto out_put_forget;
+#ifdef CONFIG_FUSE_BPF
+ if (err == sizeof(*bpf_outarg)) {
+ /* TODO Make sure this handles invalid handles */
+ /* TODO Do we need the same code in revalidate */
+ struct file *backing_file;
+ struct inode *backing_inode;
- *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
- &outarg->attr, entry_attr_timeout(outarg),
- attr_version);
+ err = -ENOENT;
+ if (!entry)
+ goto out_queue_forget;
+
+ err = -EINVAL;
+ if (bpf_outarg->backing_action != FUSE_ACTION_REPLACE)
+ goto out_queue_forget;
+
+ backing_file = fuse_fget(fm->fc, bpf_outarg->backing_fd);
+ if (!backing_file)
+ goto out_queue_forget;
+
+ /* TODO userspace doesn't really know when the right time to
+ * close the passed fd is. This because after replying to the
+ * driver request, so assume that after a lookup with bpf_args,
+ * the daemon passes the fd ownership to the kernel, which also
+ * takes care of closing it at the right time.
+ */
+ __close_fd(fm->fc->task->files, bpf_outarg->backing_fd);
+
+ backing_inode = backing_file->f_inode;
+ *inode = fuse_iget_backing(sb, backing_inode);
+ if (!*inode)
+ goto bpf_outarg_out;
+
+ if (bpf_outarg->bpf_action == FUSE_ACTION_REPLACE) {
+ struct bpf_prog *bpf_prog = fuse_get_bpf_prog(fm->fc,
+ bpf_outarg->bpf_fd);
+
+ if (IS_ERR(bpf_prog)) {
+ iput(*inode);
+ *inode = NULL;
+ err = PTR_ERR(bpf_prog);
+ goto bpf_outarg_out;
+ }
+ get_fuse_inode(*inode)->bpf = bpf_prog;
+ }
+
+ get_fuse_dentry(entry)->backing_path = backing_file->f_path;
+ path_get(&get_fuse_dentry(entry)->backing_path);
+
+bpf_outarg_out:
+ fput(backing_file);
+ } else
+#endif
+ {
+ /* Zero nodeid is same as -ENOENT, but with valid timeout */
+ if (err || !outarg->nodeid)
+ goto out_put_forget;
+
+ err = -EIO;
+ if (!outarg->nodeid)
+ goto out_put_forget;
+ if (fuse_invalid_attr(&outarg->attr))
+ goto out_put_forget;
+
+ *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
+ &outarg->attr, entry_attr_timeout(outarg),
+ attr_version);
+ }
+
err = -ENOMEM;
- if (!*inode) {
+#ifdef CONFIG_FUSE_BPF
+out_queue_forget:
+#endif
+ if (!*inode && outarg->nodeid) {
fuse_queue_forget(fm->fc, forget, outarg->nodeid, 1);
goto out;
}
@@ -486,17 +582,29 @@
{
int err;
struct fuse_entry_out outarg;
+ struct fuse_entry_bpf_out bpf_outarg = {0};
struct inode *inode;
struct dentry *newent;
bool outarg_valid = true;
bool locked;
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(dir, struct fuse_lookup_io,
+ fuse_lookup_initialize, fuse_lookup_backing,
+ fuse_lookup_finalize,
+ dir, entry, flags);
+ if (fer.ret)
+ return fer.result;
+#endif
+
if (fuse_is_bad(dir))
return ERR_PTR(-EIO);
locked = fuse_lock_inode(dir);
err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
- &outarg, &inode);
+ &outarg, &bpf_outarg, entry, &inode);
fuse_unlock_inode(dir, locked);
if (err == -ENOENT) {
outarg_valid = false;
@@ -555,6 +663,20 @@
/* Userspace expects S_IFREG in create mode */
BUG_ON((mode & S_IFMT) != S_IFREG);
+#ifdef CONFIG_FUSE_BPF
+ {
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(dir, struct fuse_create_open_io,
+ fuse_create_open_initialize,
+ fuse_create_open_backing,
+ fuse_create_open_finalize,
+ dir, entry, file, flags, mode);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+ }
+#endif
+
forget = fuse_alloc_forget();
err = -ENOMEM;
if (!forget)
@@ -747,6 +869,17 @@
struct fuse_mount *fm = get_fuse_mount(dir);
FUSE_ARGS(args);
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(dir, struct fuse_mknod_in,
+ fuse_mknod_initialize, fuse_mknod_backing,
+ fuse_mknod_finalize,
+ dir, entry, mode, rdev);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
if (!fm->fc->dont_mask)
mode &= ~current_umask();
@@ -775,6 +908,17 @@
struct fuse_mount *fm = get_fuse_mount(dir);
FUSE_ARGS(args);
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(dir, struct fuse_mkdir_in,
+ fuse_mkdir_initialize, fuse_mkdir_backing,
+ fuse_mkdir_finalize,
+ dir, entry, mode);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
if (!fm->fc->dont_mask)
mode &= ~current_umask();
@@ -797,6 +941,17 @@
unsigned len = strlen(link) + 1;
FUSE_ARGS(args);
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(dir, struct fuse_dummy_io,
+ fuse_symlink_initialize, fuse_symlink_backing,
+ fuse_symlink_finalize,
+ dir, entry, link, len);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
args.opcode = FUSE_SYMLINK;
args.in_numargs = 2;
args.in_args[0].size = entry->d_name.len + 1;
@@ -823,6 +978,20 @@
if (fuse_is_bad(dir))
return -EIO;
+#ifdef CONFIG_FUSE_BPF
+ {
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(dir, struct fuse_dummy_io,
+ fuse_unlink_initialize,
+ fuse_unlink_backing,
+ fuse_unlink_finalize,
+ dir, entry);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+ }
+#endif
+
args.opcode = FUSE_UNLINK;
args.nodeid = get_node_id(dir);
args.in_numargs = 1;
@@ -862,6 +1031,20 @@
if (fuse_is_bad(dir))
return -EIO;
+#ifdef CONFIG_FUSE_BPF
+ {
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(dir, struct fuse_dummy_io,
+ fuse_rmdir_initialize,
+ fuse_rmdir_backing,
+ fuse_rmdir_finalize,
+ dir, entry);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+ }
+#endif
+
args.opcode = FUSE_RMDIR;
args.nodeid = get_node_id(dir);
args.in_numargs = 1;
@@ -947,6 +1130,18 @@
return -EINVAL;
if (flags) {
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(olddir, struct fuse_rename2_in,
+ fuse_rename2_initialize, fuse_rename2_backing,
+ fuse_rename2_finalize,
+ olddir, oldent, newdir, newent, flags);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
+ /* TODO: how should this go with bpfs involved? */
if (fc->no_rename2 || fc->minor < 23)
return -EINVAL;
@@ -958,6 +1153,17 @@
err = -EINVAL;
}
} else {
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(olddir, struct fuse_rename_in,
+ fuse_rename_initialize, fuse_rename_backing,
+ fuse_rename_finalize,
+ olddir, oldent, newdir, newent);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
err = fuse_rename_common(olddir, oldent, newdir, newent, 0,
FUSE_RENAME,
sizeof(struct fuse_rename_in));
@@ -975,6 +1181,16 @@
struct fuse_mount *fm = get_fuse_mount(inode);
FUSE_ARGS(args);
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_link_in, fuse_link_initialize,
+ fuse_link_backing, fuse_link_finalize, entry,
+ newdir, newent);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
memset(&inarg, 0, sizeof(inarg));
inarg.oldnodeid = get_node_id(inode);
args.opcode = FUSE_LINK;
@@ -1075,23 +1291,13 @@
args.out_args[0].size = sizeof(outarg);
args.out_args[0].value = &outarg;
err = fuse_simple_request(fm, &args);
- if (!err) {
- if (fuse_invalid_attr(&outarg.attr) ||
- inode_wrong_type(inode, outarg.attr.mode)) {
- fuse_make_bad(inode);
- err = -EIO;
- } else {
- fuse_change_attributes(inode, &outarg.attr,
- attr_timeout(&outarg),
- attr_version);
- if (stat)
- fuse_fillattr(inode, &outarg.attr, stat);
- }
- }
+ if (!err)
+ err = finalize_attr(inode, &outarg, attr_version, stat);
return err;
}
static int fuse_update_get_attr(struct inode *inode, struct file *file,
+ const struct path *path,
struct kstat *stat, u32 request_mask,
unsigned int flags)
{
@@ -1099,6 +1305,17 @@
int err = 0;
bool sync;
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_getattr_io,
+ fuse_getattr_initialize, fuse_getattr_backing,
+ fuse_getattr_finalize,
+ path->dentry, stat, request_mask, flags);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
if (flags & AT_STATX_FORCE_SYNC)
sync = true;
else if (flags & AT_STATX_DONT_SYNC)
@@ -1123,7 +1340,7 @@
int fuse_update_attributes(struct inode *inode, struct file *file)
{
/* Do *not* need to get atime for internal purposes */
- return fuse_update_get_attr(inode, file, NULL,
+ return fuse_update_get_attr(inode, file, &file->f_path, NULL,
STATX_BASIC_STATS & ~STATX_ATIME, 0);
}
@@ -1232,6 +1449,16 @@
struct fuse_access_in inarg;
int err;
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_access_in,
+ fuse_access_initialize, fuse_access_backing,
+ fuse_access_finalize, inode, mask);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
BUG_ON(mask & MAY_NOT_BLOCK);
if (fm->fc->no_access)
@@ -1258,6 +1485,7 @@
return -ECHILD;
forget_all_cached_acls(inode);
+ /* TODO: BPF stuff here? But we have no dentry for path for vfs_getattr */
return fuse_do_getattr(inode, NULL, NULL);
}
@@ -1381,6 +1609,21 @@
if (fuse_is_bad(inode))
goto out_err;
+#ifdef CONFIG_FUSE_BPF
+ {
+ struct fuse_err_ret fer;
+ const char *out = NULL;
+
+ fer = fuse_bpf_backing(inode, struct fuse_dummy_io,
+ fuse_get_link_initialize,
+ fuse_get_link_backing,
+ fuse_get_link_finalize,
+ inode, dentry, callback, &out);
+ if (fer.ret)
+ return fer.result ?: out;
+ }
+#endif
+
if (fc->cache_symlinks)
return page_get_link(dentry, inode, callback);
@@ -1414,8 +1657,18 @@
static int fuse_dir_release(struct inode *inode, struct file *file)
{
- fuse_release_common(file, true);
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+ fer = fuse_bpf_backing(inode, struct fuse_release_in,
+ fuse_releasedir_initialize, fuse_release_backing,
+ fuse_release_finalize,
+ inode, file);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
+ fuse_release_common(file, true);
return 0;
}
@@ -1429,6 +1682,19 @@
if (fuse_is_bad(inode))
return -EIO;
+#ifdef CONFIG_FUSE_BFP
+ {
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_fsync_in,
+ fuse_dir_fsync_initialize, fuse_fsync_backing,
+ fuse_fsync_finalize,
+ file, start, end, datasync);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+ }
+#endif
+
if (fc->no_fsyncdir)
return 0;
@@ -1580,6 +1846,16 @@
bool trust_local_cmtime = is_wb && S_ISREG(inode->i_mode);
bool fault_blocked = false;
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_setattr_io,
+ fuse_setattr_initialize, fuse_setattr_backing,
+ fuse_setattr_finalize, dentry, attr, file);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
if (!fc->default_permissions)
attr->ia_valid |= ATTR_FORCE;
@@ -1743,11 +2019,22 @@
* This should be done on write(), truncate() and chown().
*/
if (!fc->handle_killpriv) {
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
/*
* ia_mode calculation may have used stale i_mode.
* Refresh and recalculate.
*/
- ret = fuse_do_getattr(inode, NULL, file);
+ fer = fuse_bpf_backing(inode, struct fuse_getattr_io,
+ fuse_getattr_initialize, fuse_getattr_backing,
+ fuse_getattr_finalize,
+ entry, NULL, 0, 0);
+ if (fer.ret)
+ ret = PTR_ERR(fer.result);
+ else
+#endif
+ ret = fuse_do_getattr(inode, NULL, file);
if (ret)
return ret;
@@ -1803,7 +2090,8 @@
return -EACCES;
}
- return fuse_update_get_attr(inode, NULL, stat, request_mask, flags);
+ return fuse_update_get_attr(inode, NULL, path, stat, request_mask,
+ flags);
}
static const struct inode_operations fuse_dir_inode_operations = {
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 09610d2..7a9e6a2 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -8,6 +8,7 @@
#include "fuse_i.h"
+#include <linux/filter.h>
#include <linux/pagemap.h>
#include <linux/slab.h>
#include <linux/kernel.h>
@@ -137,7 +138,11 @@
struct fuse_file *ff;
int opcode = isdir ? FUSE_OPENDIR : FUSE_OPEN;
- ff = fuse_file_alloc(fm);
+ if (file->private_data) {
+ ff = file->private_data;
+ file->private_data = NULL;
+ } else
+ ff = fuse_file_alloc(fm);
if (!ff)
return -ENOMEM;
@@ -236,6 +241,20 @@
if (err)
return err;
+#ifdef CONFIG_FUSE_BPF
+ {
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_open_io,
+ fuse_open_initialize,
+ fuse_open_backing,
+ fuse_open_finalize,
+ inode, file, isdir);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+ }
+#endif
+
if (is_wb_truncate || dax_truncate) {
inode_lock(inode);
fuse_set_nowrite(inode);
@@ -334,6 +353,17 @@
{
struct fuse_conn *fc = get_fuse_conn(inode);
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_release_in,
+ fuse_release_initialize, fuse_release_backing,
+ fuse_release_finalize,
+ inode, file);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
/* see fuse_vma_close() for !writeback_cache case */
if (fc->writeback_cache)
write_inode_now(inode, 1);
@@ -471,6 +501,17 @@
FUSE_ARGS(args);
int err;
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(file->f_inode, struct fuse_flush_in,
+ fuse_flush_initialize, fuse_flush_backing,
+ fuse_flush_finalize,
+ file, id);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
if (fuse_is_bad(inode))
return -EIO;
@@ -543,6 +584,17 @@
struct fuse_conn *fc = get_fuse_conn(inode);
int err;
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_fsync_in,
+ fuse_fsync_initialize, fuse_fsync_backing,
+ fuse_fsync_finalize,
+ file, start, end, datasync);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
if (fuse_is_bad(inode))
return -EIO;
@@ -1586,6 +1638,20 @@
if (FUSE_IS_DAX(inode))
return fuse_dax_read_iter(iocb, to);
+#ifdef CONFIG_FUSE_BPF
+ {
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_read_in,
+ fuse_file_read_iter_initialize,
+ fuse_file_read_iter_backing,
+ fuse_file_read_iter_finalize,
+ iocb, to);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+ }
+#endif
+
if (ff->passthrough.filp)
return fuse_passthrough_read_iter(iocb, to);
else if (!(ff->open_flags & FOPEN_DIRECT_IO))
@@ -1606,6 +1672,20 @@
if (FUSE_IS_DAX(inode))
return fuse_dax_write_iter(iocb, from);
+#ifdef CONFIG_FUSE_BPF
+ {
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_file_write_iter_io,
+ fuse_file_write_iter_initialize,
+ fuse_file_write_iter_backing,
+ fuse_file_write_iter_finalize,
+ iocb, from);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+ }
+#endif
+
if (ff->passthrough.filp)
return fuse_passthrough_write_iter(iocb, from);
else if (!(ff->open_flags & FOPEN_DIRECT_IO))
@@ -1855,6 +1935,19 @@
struct fuse_file *ff;
int err;
+ /**
+ * TODO - fully understand why this is necessary
+ *
+ * With fuse-bpf, fsstress fails if rename is enabled without this
+ *
+ * We are getting writes here on directory inodes, which do not have an
+ * initialized file list so crash.
+ *
+ * The question is why we are getting those writes
+ */
+ if (!S_ISREG(inode->i_mode))
+ return 0;
+
ff = __fuse_write_file_get(fc, fi);
err = fuse_flush_times(inode, ff);
if (ff)
@@ -3277,6 +3370,18 @@
bool block_faults = FUSE_IS_DAX(inode) && lock_inode;
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_fallocate_in,
+ fuse_file_fallocate_initialize,
+ fuse_file_fallocate_backing,
+ fuse_file_fallocate_finalize,
+ file, mode, offset, length);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
return -EOPNOTSUPP;
diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index 6b607f9..63b97ff 100644
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -13,6 +13,8 @@
# define pr_fmt(fmt) "fuse: " fmt
#endif
+#include <linux/filter.h>
+#include <linux/pagemap.h>
#include <linux/fuse.h>
#include <linux/fs.h>
#include <linux/mount.h>
@@ -63,11 +65,57 @@
struct fuse_forget_link *next;
};
+/** FUSE specific dentry data */
+#if BITS_PER_LONG < 64 || defined(CONFIG_FUSE_BPF)
+struct fuse_dentry {
+ union {
+ u64 time;
+ struct rcu_head rcu;
+ };
+ struct path backing_path;
+};
+
+static inline struct fuse_dentry *get_fuse_dentry(const struct dentry *entry)
+{
+ return entry->d_fsdata;
+}
+#endif
+
+#ifdef CONFIG_FUSE_BPF
+static inline void get_fuse_backing_path(const struct dentry *d,
+ struct path *path)
+{
+ struct fuse_dentry *di = get_fuse_dentry(d);
+
+ if (!di) {
+ *path = (struct path) {};
+ return;
+ }
+
+ *path = di->backing_path;
+ path_get(path);
+}
+#endif
+
/** FUSE inode */
struct fuse_inode {
/** Inode data */
struct inode inode;
+#ifdef CONFIG_FUSE_BPF
+ /**
+ * Backing inode, if this inode is from a backing file system.
+ * If this is set, nodeid is 0.
+ */
+ struct inode *backing_inode;
+
+ /**
+ * bpf_prog, run on all operations to determine whether to pass through
+ * or handle in place
+ */
+ struct bpf_prog *bpf;
+#endif
+
/** Unique ID, which identifies the inode between userspace
* and kernel */
u64 nodeid;
@@ -239,6 +287,14 @@
/** Container for data related to the passthrough functionality */
struct fuse_passthrough passthrough;
+#ifdef CONFIG_FUSE_BPF
+ /**
+ * TODO: Reconcile with passthrough file
+ * backing file when in bpf mode
+ */
+ struct file *backing_file;
+#endif
+
/** RB node to be linked on fuse_conn->polled_files */
struct rb_node polled_node;
@@ -488,6 +544,8 @@
unsigned int max_read;
unsigned int blksize;
const char *subtype;
+ struct bpf_prog *root_bpf;
+ struct file *root_dir;
/* DAX device, may be NULL */
struct dax_device *dax_dev;
@@ -780,6 +838,9 @@
/** Protects passthrough_req */
spinlock_t passthrough_req_lock;
+
+ /** task_struct for fd lookups in fuse-bpf */
+ struct task_struct *task;
};
/*
@@ -877,12 +938,16 @@
/**
* Get a filled in inode
*/
+struct inode *fuse_iget_backing(struct super_block *sb,
+ struct inode *backing_inode);
struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
int generation, struct fuse_attr *attr,
u64 attr_valid, u64 attr_version);
int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name,
- struct fuse_entry_out *outarg, struct inode **inode);
+ struct fuse_entry_out *outarg,
+ struct fuse_entry_bpf_out *bpf_outarg,
+ struct dentry *entry, struct inode **inode);
/**
* Send FORGET command
@@ -1019,6 +1084,7 @@
void fuse_invalidate_atime(struct inode *inode);
u64 entry_attr_timeout(struct fuse_entry_out *o);
+void fuse_init_dentry_root(struct dentry *root, struct file *backing_dir);
void fuse_change_entry_timeout(struct dentry *entry, struct fuse_entry_out *o);
/**
@@ -1233,6 +1299,293 @@
ssize_t fuse_passthrough_write_iter(struct kiocb *iocb, struct iov_iter *from);
ssize_t fuse_passthrough_mmap(struct file *file, struct vm_area_struct *vma);
+/* backing.c */
+
+struct file *fuse_fget(struct fuse_conn *fc, unsigned int fd);
+struct bpf_prog *fuse_get_bpf_prog(struct fuse_conn *fc, unsigned int fd);
+
+/*
+ * Dummy io passed to fuse_bpf_backing when io operation needs no scratch space
+ */
+struct fuse_dummy_io {
+ int unused;
+};
+
+struct fuse_open_io {
+ struct fuse_open_in foi;
+ struct fuse_open_out foo;
+};
+
+int fuse_open_initialize(struct fuse_args *fa, struct fuse_open_io *foi,
+ struct inode *inode, struct file *file, bool isdir);
+int fuse_open_backing(struct fuse_args *fa,
+ struct inode *inode, struct file *file, bool isdir);
+void *fuse_open_finalize(struct fuse_args *fa,
+ struct inode *inode, struct file *file, bool isdir);
+
+struct fuse_create_open_io {
+ struct fuse_create_in fci;
+ struct fuse_entry_out feo;
+ struct fuse_open_out foo;
+};
+
+int fuse_create_open_initialize(
+ struct fuse_args *fa, struct fuse_create_open_io *fcoi,
+ struct inode *dir, struct dentry *entry,
+ struct file *file, unsigned int flags, umode_t mode);
+int fuse_create_open_backing(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry,
+ struct file *file, unsigned int flags, umode_t mode);
+void *fuse_create_open_finalize(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry,
+ struct file *file, unsigned int flags, umode_t mode);
+
+int fuse_mknod_initialize(
+ struct fuse_args *fa, struct fuse_mknod_in *fmi,
+ struct inode *dir, struct dentry *entry, umode_t mode, dev_t rdev);
+int fuse_mknod_backing(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry, umode_t mode, dev_t rdev);
+void *fuse_mknod_finalize(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry, umode_t mode, dev_t rdev);
+
+int fuse_mkdir_initialize(
+ struct fuse_args *fa, struct fuse_mkdir_in *fmi,
+ struct inode *dir, struct dentry *entry, umode_t mode);
+int fuse_mkdir_backing(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry, umode_t mode);
+void *fuse_mkdir_finalize(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry, umode_t mode);
+
+int fuse_rmdir_initialize(
+ struct fuse_args *fa, struct fuse_dummy_io *fmi,
+ struct inode *dir, struct dentry *entry);
+int fuse_rmdir_backing(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry);
+void *fuse_rmdir_finalize(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry);
+
+int fuse_rename2_initialize(struct fuse_args *fa, struct fuse_rename2_in *fri,
+ struct inode *olddir, struct dentry *oldent,
+ struct inode *newdir, struct dentry *newent,
+ unsigned int flags);
+int fuse_rename2_backing(struct fuse_args *fa,
+ struct inode *olddir, struct dentry *oldent,
+ struct inode *newdir, struct dentry *newent,
+ unsigned int flags);
+void *fuse_rename2_finalize(struct fuse_args *fa,
+ struct inode *olddir, struct dentry *oldent,
+ struct inode *newdir, struct dentry *newent,
+ unsigned int flags);
+
+int fuse_rename_initialize(struct fuse_args *fa, struct fuse_rename_in *fri,
+ struct inode *olddir, struct dentry *oldent,
+ struct inode *newdir, struct dentry *newent);
+int fuse_rename_backing(struct fuse_args *fa,
+ struct inode *olddir, struct dentry *oldent,
+ struct inode *newdir, struct dentry *newent);
+void *fuse_rename_finalize(struct fuse_args *fa,
+ struct inode *olddir, struct dentry *oldent,
+ struct inode *newdir, struct dentry *newent);
+
+int fuse_unlink_initialize(
+ struct fuse_args *fa, struct fuse_dummy_io *fmi,
+ struct inode *dir, struct dentry *entry);
+int fuse_unlink_backing(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry);
+void *fuse_unlink_finalize(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry);
+
+int fuse_link_initialize(struct fuse_args *fa, struct fuse_link_in *fli,
+ struct dentry *entry, struct inode *dir,
+ struct dentry *newent);
+int fuse_link_backing(struct fuse_args *fa, struct dentry *entry,
+ struct inode *dir, struct dentry *newent);
+void *fuse_link_finalize(struct fuse_args *fa, struct dentry *entry,
+ struct inode *dir, struct dentry *newent);
+
+int fuse_release_initialize(struct fuse_args *fa, struct fuse_release_in *fri,
+ struct inode *inode, struct file *file);
+int fuse_releasedir_initialize(struct fuse_args *fa,
+ struct fuse_release_in *fri,
+ struct inode *inode, struct file *file);
+int fuse_release_backing(struct fuse_args *fa,
+ struct inode *inode, struct file *file);
+void *fuse_release_finalize(struct fuse_args *fa,
+ struct inode *inode, struct file *file);
+
+int fuse_flush_initialize(struct fuse_args *fa, struct fuse_flush_in *ffi,
+ struct file *file, fl_owner_t id);
+int fuse_flush_backing(struct fuse_args *fa, struct file *file, fl_owner_t id);
+void *fuse_flush_finalize(struct fuse_args *fa,
+ struct file *file, fl_owner_t id);
+
+int fuse_fsync_initialize(struct fuse_args *fa, struct fuse_fsync_in *ffi,
+ struct file *file, loff_t start, loff_t end, int datasync);
+int fuse_fsync_backing(struct fuse_args *fa,
+ struct file *file, loff_t start, loff_t end, int datasync);
+void *fuse_fsync_finalize(struct fuse_args *fa,
+ struct file *file, loff_t start, loff_t end, int datasync);
+int fuse_dir_fsync_initialize(struct fuse_args *fa, struct fuse_fsync_in *ffi,
+ struct file *file, loff_t start, loff_t end, int datasync);
+
+struct fuse_getxattr_io {
+ struct fuse_getxattr_in fgi;
+ struct fuse_getxattr_out fgo;
+};
+
+int fuse_getxattr_initialize(
+ struct fuse_args *fa, struct fuse_getxattr_io *fgio,
+ struct dentry *dentry, const char *name, void *value,
+ size_t size);
+int fuse_getxattr_backing(
+ struct fuse_args *fa,
+ struct dentry *dentry, const char *name, void *value,
+ size_t size);
+void *fuse_getxattr_finalize(
+ struct fuse_args *fa,
+ struct dentry *dentry, const char *name, void *value,
+ size_t size);
+
+int fuse_listxattr_initialize(struct fuse_args *fa,
+ struct fuse_getxattr_io *fgio,
+ struct dentry *dentry, char *list, size_t size);
+int fuse_listxattr_backing(struct fuse_args *fa, struct dentry *dentry,
+ char *list, size_t size);
+void *fuse_listxattr_finalize(struct fuse_args *fa, struct dentry *dentry,
+ char *list, size_t size);
+
+int fuse_setxattr_initialize(struct fuse_args *fa,
+ struct fuse_setxattr_in *fsxi,
+ struct dentry *dentry, const char *name,
+ const void *value, size_t size, int flags);
+int fuse_setxattr_backing(struct fuse_args *fa, struct dentry *dentry,
+ const char *name, const void *value, size_t size,
+ int flags);
+void *fuse_setxattr_finalize(struct fuse_args *fa, struct dentry *dentry,
+ const char *name, const void *value, size_t size,
+ int flags);
+
+int fuse_file_read_iter_initialize(
+ struct fuse_args *fa, struct fuse_read_in *fri,
+ struct kiocb *iocb, struct iov_iter *to);
+int fuse_file_read_iter_backing(struct fuse_args *fa,
+ struct kiocb *iocb, struct iov_iter *to);
+void *fuse_file_read_iter_finalize(struct fuse_args *fa,
+ struct kiocb *iocb, struct iov_iter *to);
+
+struct fuse_file_write_iter_io {
+ struct fuse_write_in fwi;
+ struct fuse_write_out fwo;
+};
+
+int fuse_file_write_iter_initialize(
+ struct fuse_args *fa, struct fuse_file_write_iter_io *fwio,
+ struct kiocb *iocb, struct iov_iter *from);
+int fuse_file_write_iter_backing(struct fuse_args *fa,
+ struct kiocb *iocb, struct iov_iter *from);
+void *fuse_file_write_iter_finalize(struct fuse_args *fa,
+ struct kiocb *iocb, struct iov_iter *from);
+
+int fuse_file_fallocate_initialize(struct fuse_args *fa,
+ struct fuse_fallocate_in *ffi,
+ struct file *file, int mode, loff_t offset, loff_t length);
+int fuse_file_fallocate_backing(struct fuse_args *fa,
+ struct file *file, int mode, loff_t offset, loff_t length);
+void *fuse_file_fallocate_finalize(struct fuse_args *fa,
+ struct file *file, int mode, loff_t offset, loff_t length);
+
+struct fuse_lookup_io {
+ struct fuse_entry_out feo;
+ struct fuse_entry_bpf_out febo;
+};
+
+int fuse_lookup_initialize(struct fuse_args *fa, struct fuse_lookup_io *feo,
+ struct inode *dir, struct dentry *entry, unsigned int flags);
+int fuse_lookup_backing(struct fuse_args *fa, struct inode *dir,
+ struct dentry *entry, unsigned int flags);
+struct dentry *fuse_lookup_finalize(struct fuse_args *fa, struct inode *dir,
+ struct dentry *entry, unsigned int flags);
+int fuse_revalidate_backing(struct fuse_args *fa, struct inode *dir,
+ struct dentry *entry, unsigned int flags);
+void *fuse_revalidate_finalize(struct fuse_args *fa, struct inode *dir,
+ struct dentry *entry, unsigned int flags);
+
+struct fuse_getattr_io {
+ struct fuse_getattr_in fgi;
+ struct fuse_attr_out fao;
+};
+int fuse_getattr_initialize(struct fuse_args *fa, struct fuse_getattr_io *fgio,
+ const struct dentry *entry, struct kstat *stat,
+ u32 request_mask, unsigned int flags);
+int fuse_getattr_backing(struct fuse_args *fa,
+ const struct dentry *entry, struct kstat *stat,
+ u32 request_mask, unsigned int flags);
+void *fuse_getattr_finalize(struct fuse_args *fa,
+ const struct dentry *entry, struct kstat *stat,
+ u32 request_mask, unsigned int flags);
+
+struct fuse_setattr_io {
+ struct fuse_setattr_in fsi;
+ struct fuse_attr_out fao;
+};
+
+int fuse_setattr_initialize(struct fuse_args *fa, struct fuse_setattr_io *fsi,
+ struct dentry *dentry, struct iattr *attr, struct file *file);
+int fuse_setattr_backing(struct fuse_args *fa,
+ struct dentry *dentry, struct iattr *attr, struct file *file);
+void *fuse_setattr_finalize(struct fuse_args *fa,
+ struct dentry *dentry, struct iattr *attr, struct file *file);
+
+int fuse_get_link_initialize(struct fuse_args *fa, struct fuse_dummy_io *dummy,
+ struct inode *inode, struct dentry *dentry,
+ struct delayed_call *callback, const char **out);
+int fuse_get_link_backing(struct fuse_args *fa,
+ struct inode *inode, struct dentry *dentry,
+ struct delayed_call *callback, const char **out);
+void *fuse_get_link_finalize(struct fuse_args *fa,
+ struct inode *inode, struct dentry *dentry,
+ struct delayed_call *callback, const char **out);
+
+int fuse_symlink_initialize(
+ struct fuse_args *fa, struct fuse_dummy_io *unused,
+ struct inode *dir, struct dentry *entry, const char *link, int len);
+int fuse_symlink_backing(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry, const char *link, int len);
+void *fuse_symlink_finalize(
+ struct fuse_args *fa,
+ struct inode *dir, struct dentry *entry, const char *link, int len);
+
+struct fuse_read_io {
+ struct fuse_read_in fri;
+ struct fuse_read_out fro;
+};
+
+int fuse_readdir_initialize(struct fuse_args *fa, struct fuse_read_io *frio,
+ struct file *file, struct dir_context *ctx,
+ bool *force_again, bool *allow_force);
+int fuse_readdir_backing(struct fuse_args *fa,
+ struct file *file, struct dir_context *ctx,
+ bool *force_again, bool *allow_force);
+void *fuse_readdir_finalize(struct fuse_args *fa,
+ struct file *file, struct dir_context *ctx,
+ bool *force_again, bool *allow_force);
+
+int fuse_access_initialize(struct fuse_args *fa, struct fuse_access_in *fai,
+ struct inode *inode, int mask);
+int fuse_access_backing(struct fuse_args *fa, struct inode *inode, int mask);
+void *fuse_access_finalize(struct fuse_args *fa, struct inode *inode, int mask);
+
/*
* FUSE caches dentries and attributes with separate timeout. The
* time in jiffies until the dentry/attributes are valid is stored in
@@ -1315,4 +1668,168 @@
}
}
+static inline int finalize_attr(struct inode *inode, struct fuse_attr_out *outarg,
+ u64 attr_version, struct kstat *stat)
+{
+ int err = 0;
+
+ if (fuse_invalid_attr(&outarg->attr) ||
+ ((inode->i_mode ^ outarg->attr.mode) & S_IFMT)) {
+ fuse_make_bad(inode);
+ err = -EIO;
+ } else {
+ fuse_change_attributes(inode, &outarg->attr,
+ attr_timeout(outarg),
+ attr_version);
+ if (stat)
+ fuse_fillattr(inode, &outarg->attr, stat);
+ }
+ return err;
+}
+
+#ifdef CONFIG_FUSE_BPF
+struct fuse_err_ret {
+ void *result;
+ bool ret;
+};
+
+/*
+ * expression statement to wrap the backing filter logic
+ * struct inode *inode: inode with bpf and backing inode
+ * typedef io: (typically complex) type whose components fuse_args can point to.
+ * An instance of this type is created locally and passed to initialize
+ * void initialize(struct fuse_args *fa, io *in_out, args...): function that sets
+ * up fa and io based on args
+ * int backing(struct fuse_args *fa, args...): function that actually performs
+ * the backing io operation
+ * void *finalize(struct fuse_args *, args...): function that performs any final
+ * work needed to commit the backing io
+ */
+#define fuse_bpf_backing(inode, io, initialize, backing, finalize, \
+ args...) \
+({ \
+ struct fuse_err_ret fer = {0}; \
+ int ext_flags; \
+ struct fuse_inode *fuse_inode = get_fuse_inode(inode); \
+ struct fuse_mount *fm = get_fuse_mount(inode); \
+ io feo = {0}; \
+ struct fuse_args fa = {0}, fa_backup = {0}; \
+ bool locked; \
+ ssize_t res; \
+ void *err; \
+ int i; \
+ bool initialized = false; \
+ \
+ do { \
+ if (!fuse_inode || !fuse_inode->backing_inode) \
+ break; \
+ \
+ err = ERR_PTR(initialize(&fa, &feo, args)); \
+ if (err) { \
+ fer = (struct fuse_err_ret) { \
+ err, \
+ true, \
+ }; \
+ break; \
+ } \
+ initialized = true; \
+ \
+ fa_backup = fa; \
+ fa.opcode |= FUSE_PREFILTER; \
+ for (i = 0; i < fa.in_numargs; ++i) \
+ fa.out_args[i] = (struct fuse_arg) { \
+ .size = fa.in_args[i].size, \
+ .value = (void *)fa.in_args[i].value, \
+ }; \
+ fa.out_numargs = fa.in_numargs; \
+ \
+ ext_flags = fuse_inode->bpf ? \
+ BPF_PROG_RUN(fuse_inode->bpf, &fa) : \
+ FUSE_BPF_BACKING; \
+ if (ext_flags < 0) { \
+ fer = (struct fuse_err_ret) { \
+ ERR_PTR(ext_flags), \
+ true, \
+ }; \
+ break; \
+ } \
+ \
+ if (ext_flags & FUSE_BPF_USER_FILTER) { \
+ locked = fuse_lock_inode(inode); \
+ res = fuse_simple_request(fm, &fa); \
+ fuse_unlock_inode(inode, locked); \
+ if (res < 0) { \
+ fer = (struct fuse_err_ret) { \
+ ERR_PTR(res), \
+ true, \
+ }; \
+ break; \
+ } \
+ } \
+ \
+ if (!(ext_flags & FUSE_BPF_BACKING)) \
+ break; \
+ \
+ fa.opcode &= ~FUSE_PREFILTER; \
+ for (i = 0; i < fa.in_numargs; ++i) \
+ fa.in_args[i] = (struct fuse_in_arg) { \
+ .size = fa.out_args[i].size, \
+ .value = fa.out_args[i].value, \
+ }; \
+ for (i = 0; i < fa.out_numargs; ++i) \
+ fa.out_args[i] = (struct fuse_arg) { \
+ .size = fa_backup.out_args[i].size, \
+ .value = fa_backup.out_args[i].value, \
+ }; \
+ fa.out_numargs = fa_backup.out_numargs; \
+ \
+ fer = (struct fuse_err_ret) { \
+ ERR_PTR(backing(&fa, args)), \
+ true, \
+ }; \
+ if (!(ext_flags & FUSE_BPF_POST_FILTER)) \
+ break; \
+ \
+ fa.opcode |= FUSE_POSTFILTER; \
+ if (IS_ERR(fer.result)) \
+ fa.error_in = PTR_ERR(fer.result); \
+ for (i = 0; i < fa.out_numargs; ++i) \
+ fa.in_args[fa.in_numargs++] = \
+ (struct fuse_in_arg) { \
+ .size = fa.out_args[i].size, \
+ .value = fa.out_args[i].value, \
+ }; \
+ ext_flags = BPF_PROG_RUN(fuse_inode->bpf, &fa); \
+ if (ext_flags < 0) { \
+ fer = (struct fuse_err_ret) { \
+ ERR_PTR(ext_flags), \
+ true, \
+ }; \
+ break; \
+ } \
+ if (!(ext_flags & FUSE_BPF_USER_FILTER)) \
+ break; \
+ \
+ fa.out_args[0].size = fa_backup.out_args[0].size; \
+ fa.out_args[1].size = fa_backup.out_args[1].size; \
+ fa.out_numargs = fa_backup.out_numargs; \
+ locked = fuse_lock_inode(inode); \
+ res = fuse_simple_request(fm, &fa); \
+ fuse_unlock_inode(inode, locked); \
+ if (res < 0) { \
+ fer.result = ERR_PTR(res); \
+ break; \
+ } \
+ } while (false); \
+ \
+ if (initialized && fer.ret) { \
+ err = finalize(&fa, args); \
+ if (err) \
+ fer.result = err; \
+ } \
+ \
+ fer; \
+})
+#endif /* CONFIG_FUSE_BPF */
+
#endif /* _FS_FUSE_I_H */
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 1be825e..16c5b83 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -79,6 +79,10 @@
fi->i_time = 0;
fi->inval_mask = 0;
+#ifdef CONFIG_FUSE_BPF
+ fi->backing_inode = NULL;
+ fi->bpf = NULL;
+#endif
fi->nodeid = 0;
fi->nlookup = 0;
fi->attr_version = 0;
@@ -119,6 +123,12 @@
{
struct fuse_inode *fi = get_fuse_inode(inode);
+#ifdef CONFIG_FUSE_BPF
+ iput(fi->backing_inode);
+ if (fi->bpf)
+ bpf_prog_put(fi->bpf);
+ fi->bpf = NULL;
+#endif
truncate_inode_pages_final(&inode->i_data);
clear_inode(inode);
if (inode->i_sb->s_flags & SB_ACTIVE) {
@@ -307,22 +317,74 @@
BUG();
}
+struct fuse_inode_identifier {
+ u64 nodeid;
+ struct inode *backing_inode;
+};
+
static int fuse_inode_eq(struct inode *inode, void *_nodeidp)
{
- u64 nodeid = *(u64 *) _nodeidp;
- if (get_node_id(inode) == nodeid)
- return 1;
- else
- return 0;
+ struct fuse_inode_identifier *fii =
+ (struct fuse_inode_identifier *) _nodeidp;
+ struct fuse_inode *fi = get_fuse_inode(inode);
+
+ return fii->nodeid == fi->nodeid
+#ifdef CONFIG_FUSE_BPF
+ && fii->backing_inode == fi->backing_inode
+#endif
+ ;
}
static int fuse_inode_set(struct inode *inode, void *_nodeidp)
{
- u64 nodeid = *(u64 *) _nodeidp;
- get_fuse_inode(inode)->nodeid = nodeid;
+ struct fuse_inode_identifier *fii =
+ (struct fuse_inode_identifier *) _nodeidp;
+ struct fuse_inode *fi = get_fuse_inode(inode);
+
+ fi->nodeid = fii->nodeid;
+#ifdef CONFIG_FUSE_BPF
+ fi->backing_inode = fii->backing_inode;
+ if (fi->backing_inode)
+ ihold(fi->backing_inode);
+#endif
+
return 0;
}
+struct inode *fuse_iget_backing(struct super_block *sb,
+ struct inode *backing_inode)
+{
+ struct inode *inode;
+ struct fuse_inode *fi;
+ struct fuse_conn *fc = get_fuse_conn_super(sb);
+ struct fuse_inode_identifier fii = {
+ .backing_inode = backing_inode,
+ };
+ struct fuse_attr attr;
+
+ fuse_fill_attr_from_inode(&attr, backing_inode);
+ inode = iget5_locked(sb, (unsigned long) backing_inode, fuse_inode_eq,
+ fuse_inode_set, &fii);
+ if (!inode)
+ return NULL;
+
+ if ((inode->i_state & I_NEW)) {
+ inode->i_flags |= S_NOATIME;
+ if (!fc->writeback_cache)
+ inode->i_flags |= S_NOCMTIME;
+ fuse_init_common(inode);
+ unlock_new_inode(inode);
+ }
+
+ fi = get_fuse_inode(inode);
+ fuse_init_inode(inode, &attr);
+ spin_lock(&fi->lock);
+ fi->nlookup++;
+ spin_unlock(&fi->lock);
+
+ return inode;
+}
+
struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
int generation, struct fuse_attr *attr,
u64 attr_valid, u64 attr_version)
@@ -330,6 +392,9 @@
struct inode *inode;
struct fuse_inode *fi;
struct fuse_conn *fc = get_fuse_conn_super(sb);
+ struct fuse_inode_identifier fii = {
+ .nodeid = nodeid,
+ };
/*
* Auto mount points get their node id from the submount root, which is
@@ -351,7 +416,7 @@
}
retry:
- inode = iget5_locked(sb, nodeid, fuse_inode_eq, fuse_inode_set, &nodeid);
+ inode = iget5_locked(sb, nodeid, fuse_inode_eq, fuse_inode_set, &fii);
if (!inode)
return NULL;
@@ -383,13 +448,16 @@
{
struct fuse_mount *fm_iter;
struct inode *inode;
+ struct fuse_inode_identifier fii = {
+ .nodeid = nodeid,
+ };
WARN_ON(!rwsem_is_locked(&fc->killsb));
list_for_each_entry(fm_iter, &fc->mounts, fc_entry) {
if (!fm_iter->sb)
continue;
- inode = ilookup5(fm_iter->sb, nodeid, fuse_inode_eq, &nodeid);
+ inode = ilookup5(fm_iter->sb, nodeid, fuse_inode_eq, &fii);
if (inode) {
if (fm)
*fm = fm_iter;
@@ -528,6 +596,8 @@
OPT_ALLOW_OTHER,
OPT_MAX_READ,
OPT_BLKSIZE,
+ OPT_ROOT_BPF,
+ OPT_ROOT_DIR,
OPT_ERR
};
@@ -542,6 +612,8 @@
fsparam_u32 ("max_read", OPT_MAX_READ),
fsparam_u32 ("blksize", OPT_BLKSIZE),
fsparam_string ("subtype", OPT_SUBTYPE),
+ fsparam_u32 ("root_bpf", OPT_ROOT_BPF),
+ fsparam_u32 ("root_dir", OPT_ROOT_DIR),
{}
};
@@ -625,6 +697,21 @@
ctx->blksize = result.uint_32;
break;
+ case OPT_ROOT_BPF:
+ ctx->root_bpf = bpf_prog_get_type_dev(result.uint_32,
+ BPF_PROG_TYPE_FUSE, false);
+ if (IS_ERR(ctx->root_bpf)) {
+ ctx->root_bpf = NULL;
+ return invalfc(fc, "Unable to open bpf program");
+ }
+ break;
+
+ case OPT_ROOT_DIR:
+ ctx->root_dir = fget(result.uint_32);
+ if (!ctx->root_dir)
+ return invalfc(fc, "Unable to open root directory");
+ break;
+
default:
return -EINVAL;
}
@@ -637,6 +724,10 @@
struct fuse_fs_context *ctx = fc->fs_private;
if (ctx) {
+ if (ctx->root_dir)
+ fput(ctx->root_dir);
+ if (ctx->root_bpf)
+ bpf_prog_put(ctx->root_bpf);
kfree(ctx->subtype);
kfree(ctx);
}
@@ -773,15 +864,34 @@
}
EXPORT_SYMBOL_GPL(fuse_mount_get);
-static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode)
+static struct inode *fuse_get_root_inode(struct super_block *sb,
+ unsigned int mode,
+ struct bpf_prog *root_bpf,
+ struct file *backing_fd)
{
struct fuse_attr attr;
- memset(&attr, 0, sizeof(attr));
+ struct inode *inode;
+ memset(&attr, 0, sizeof(attr));
attr.mode = mode;
attr.ino = FUSE_ROOT_ID;
attr.nlink = 1;
- return fuse_iget(sb, 1, 0, &attr, 0, 0);
+ inode = fuse_iget(sb, 1, 0, &attr, 0, 0);
+ if (!inode)
+ return NULL;
+
+#ifdef CONFIG_FUSE_BPF
+ get_fuse_inode(inode)->bpf = root_bpf;
+ if (root_bpf)
+ bpf_prog_inc(root_bpf);
+
+ if (backing_fd) {
+ get_fuse_inode(inode)->backing_inode = backing_fd->f_inode;
+ ihold(backing_fd->f_inode);
+ }
+#endif
+
+ return inode;
}
struct fuse_inode_handle {
@@ -796,20 +906,24 @@
struct inode *inode;
struct dentry *entry;
int err = -ESTALE;
+ struct fuse_inode_identifier fii = {
+ .nodeid = handle->nodeid,
+ };
if (handle->nodeid == 0)
goto out_err;
- inode = ilookup5(sb, handle->nodeid, fuse_inode_eq, &handle->nodeid);
+ inode = ilookup5(sb, handle->nodeid, fuse_inode_eq, &fii);
if (!inode) {
struct fuse_entry_out outarg;
+ struct fuse_entry_bpf_out bpf_outarg;
const struct qstr name = QSTR_INIT(".", 1);
if (!fc->export_support)
goto out_err;
err = fuse_lookup_name(sb, handle->nodeid, &name, &outarg,
- &inode);
+ &bpf_outarg, NULL, &inode);
if (err && err != -ENOENT)
goto out_err;
if (err || !inode) {
@@ -903,6 +1017,7 @@
struct inode *inode;
struct dentry *parent;
struct fuse_entry_out outarg;
+ struct fuse_entry_bpf_out bpf_outarg;
const struct qstr name = QSTR_INIT("..", 2);
int err;
@@ -910,7 +1025,7 @@
return ERR_PTR(-ESTALE);
err = fuse_lookup_name(child_inode->i_sb, get_node_id(child_inode),
- &name, &outarg, &inode);
+ &name, &outarg, &bpf_outarg, NULL, &inode);
if (err) {
if (err == -ENOENT)
return ERR_PTR(-ESTALE);
@@ -1096,6 +1211,7 @@
fc->minor = arg->minor;
fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
fc->max_write = max_t(unsigned, 4096, fc->max_write);
+ fc->task = get_task_struct(current);
fc->conn_init = 1;
}
kfree(ia);
@@ -1172,6 +1288,8 @@
idr_for_each(&fc->passthrough_req, free_fuse_passthrough, NULL);
idr_destroy(&fc->passthrough_req);
kfree_rcu(fc, rcu);
+ if (fc->task)
+ put_task_struct(fc->task);
}
EXPORT_SYMBOL_GPL(fuse_free_conn);
@@ -1397,11 +1515,13 @@
fc->no_force_umount = ctx->no_force_umount;
err = -ENOMEM;
- root = fuse_get_root_inode(sb, ctx->rootmode);
+ root = fuse_get_root_inode(sb, ctx->rootmode, ctx->root_bpf,
+ ctx->root_dir);
sb->s_d_op = &fuse_root_dentry_operations;
root_dentry = d_make_root(root);
if (!root_dentry)
goto err_dev_free;
+ fuse_init_dentry_root(root_dentry, ctx->root_dir);
/* Root dentry doesn't have .d_revalidate */
sb->s_d_op = &fuse_dentry_operations;
@@ -1697,6 +1817,26 @@
static struct kobject *fuse_kobj;
+/* TODO Remove this once BPF_PROG_TYPE_FUSE is upstreamed */
+static ssize_t bpf_prog_type_fuse_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buff)
+{
+ return sysfs_emit(buff, "%d\n", BPF_PROG_TYPE_FUSE);
+}
+
+static struct kobj_attribute bpf_prog_type_fuse_attr =
+ __ATTR_RO(bpf_prog_type_fuse);
+
+static struct attribute *bpf_attributes[] = {
+ &bpf_prog_type_fuse_attr.attr,
+ NULL,
+};
+
+static const struct attribute_group bpf_attr_group = {
+ .attrs = bpf_attributes,
+};
+/* TODO remove to here */
+
static int fuse_sysfs_init(void)
{
int err;
@@ -1711,8 +1851,15 @@
if (err)
goto out_fuse_unregister;
+ /* TODO Remove when BPF_PROG_TYPE_FUSE is upstreamed */
+ err = sysfs_create_group(fuse_kobj, &bpf_attr_group);
+ if (err)
+ goto out_fuse_remove_mount_point;
+
return 0;
+ out_fuse_remove_mount_point:
+ sysfs_remove_mount_point(fuse_kobj, "connections");
out_fuse_unregister:
kobject_put(fuse_kobj);
out_err:
diff --git a/fs/fuse/readdir.c b/fs/fuse/readdir.c
index ec1faa1..4a8a3d5 100644
--- a/fs/fuse/readdir.c
+++ b/fs/fuse/readdir.c
@@ -571,6 +571,21 @@
struct inode *inode = file_inode(file);
int err;
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+ bool force_again, allow_force;
+again:
+ fer = fuse_bpf_backing(inode, struct fuse_read_io,
+ fuse_readdir_initialize, fuse_readdir_backing,
+ fuse_readdir_finalize,
+ file, ctx, &force_again, &allow_force);
+ if (force_again && !IS_ERR(fer.result))
+ goto again;
+
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
if (fuse_is_bad(inode))
return -EIO;
diff --git a/fs/fuse/xattr.c b/fs/fuse/xattr.c
index aab4c9c..82dd7a8 100644
--- a/fs/fuse/xattr.c
+++ b/fs/fuse/xattr.c
@@ -113,6 +113,17 @@
struct fuse_getxattr_out outarg;
ssize_t ret;
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_getxattr_io,
+ fuse_listxattr_initialize,
+ fuse_listxattr_backing, fuse_listxattr_finalize,
+ entry, list, size);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
if (fuse_is_bad(inode))
return -EIO;
@@ -181,6 +192,17 @@
struct dentry *dentry, struct inode *inode,
const char *name, void *value, size_t size, int flags)
{
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_getxattr_io,
+ fuse_getxattr_initialize, fuse_getxattr_backing,
+ fuse_getxattr_finalize,
+ dentry, name, value, size);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
if (fuse_is_bad(inode))
return -EIO;
@@ -192,6 +214,17 @@
const char *name, const void *value, size_t size,
int flags)
{
+#ifdef CONFIG_FUSE_BPF
+ struct fuse_err_ret fer;
+
+ fer = fuse_bpf_backing(inode, struct fuse_setxattr_in,
+ fuse_setxattr_initialize, fuse_setxattr_backing,
+ fuse_setxattr_finalize, dentry, name, value,
+ size, flags);
+ if (fer.ret)
+ return PTR_ERR(fer.result);
+#endif
+
if (fuse_is_bad(inode))
return -EIO;
diff --git a/include/linux/bpf_types.h b/include/linux/bpf_types.h
index a8137bb..cd894ea 100644
--- a/include/linux/bpf_types.h
+++ b/include/linux/bpf_types.h
@@ -77,6 +77,9 @@
void *, void *)
#endif /* CONFIG_BPF_LSM */
#endif
+#ifdef CONFIG_FUSE_BPF
+BPF_PROG_TYPE(BPF_PROG_TYPE_FUSE, fuse, struct fuse_args, struct fuse_args)
+#endif
BPF_MAP_TYPE(BPF_MAP_TYPE_ARRAY, array_map_ops)
BPF_MAP_TYPE(BPF_MAP_TYPE_PERCPU_ARRAY, percpu_array_map_ops)
diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h
index 762bf87..26b6bee 100644
--- a/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@ -199,6 +199,7 @@
BPF_PROG_TYPE_EXT,
BPF_PROG_TYPE_LSM,
BPF_PROG_TYPE_SK_LOOKUP,
+ BPF_PROG_TYPE_FUSE,
};
enum bpf_attach_type {
diff --git a/include/uapi/linux/fuse.h b/include/uapi/linux/fuse.h
index c20b330..7b73761 100644
--- a/include/uapi/linux/fuse.h
+++ b/include/uapi/linux/fuse.h
@@ -516,6 +516,17 @@
struct fuse_attr attr;
};
+#define FUSE_ACTION_KEEP 0
+#define FUSE_ACTION_REMOVE 1
+#define FUSE_ACTION_REPLACE 2
+
+struct fuse_entry_bpf_out {
+ uint64_t backing_action;
+ uint64_t backing_fd;
+ uint64_t bpf_action;
+ uint64_t bpf_fd;
+};
+
struct fuse_forget_in {
uint64_t nlookup;
};
@@ -813,7 +824,7 @@
uint32_t uid;
uint32_t gid;
uint32_t pid;
- uint32_t padding;
+ uint32_t error_in;
};
struct fuse_out_header {
@@ -977,12 +988,20 @@
int page_zeroing:1;
int page_replace:1;
int may_block:1;
- struct fuse_in_arg in_args[3];
- struct fuse_arg out_args[2];
+ struct fuse_in_arg in_args[5];
+ struct fuse_arg out_args[3];
void (*end)(struct fuse_mount *fm, struct fuse_args *args, int error);
/* Path used for completing d_canonical_path */
struct path *canonical_path;
};
+#define FUSE_BPF_USER_FILTER 1
+#define FUSE_BPF_BACKING 2
+#define FUSE_BPF_POST_FILTER 4
+
+#define FUSE_OPCODE_FILTER 0x0ffff
+#define FUSE_PREFILTER 0x10000
+#define FUSE_POSTFILTER 0x20000
+
#endif /* _LINUX_FUSE_H */
diff --git a/kernel/bpf/Makefile b/kernel/bpf/Makefile
index c1b9f71..bfdc63d 100644
--- a/kernel/bpf/Makefile
+++ b/kernel/bpf/Makefile
@@ -36,3 +36,6 @@
obj-${CONFIG_BPF_LSM} += bpf_lsm.o
endif
obj-$(CONFIG_BPF_PRELOAD) += preload/
+ifeq ($(CONFIG_FUSE_BPF),y)
+obj-$(CONFIG_BPF_SYSCALL) += bpf_fuse.o
+endif
diff --git a/kernel/bpf/bpf_fuse.c b/kernel/bpf/bpf_fuse.c
new file mode 100644
index 0000000..2a4db5c
--- /dev/null
+++ b/kernel/bpf/bpf_fuse.c
@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (c) 2021 Google LLC
+
+#include <linux/filter.h>
+#include <linux/fuse.h>
+
+static const struct bpf_func_proto *
+fuse_prog_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)
+{
+ switch (func_id) {
+ case BPF_FUNC_trace_printk:
+ return bpf_get_trace_printk_proto();
+
+ case BPF_FUNC_get_current_uid_gid:
+ return &bpf_get_current_uid_gid_proto;
+
+ case BPF_FUNC_get_current_pid_tgid:
+ return &bpf_get_current_pid_tgid_proto;
+
+ case BPF_FUNC_map_lookup_elem:
+ return &bpf_map_lookup_elem_proto;
+
+ case BPF_FUNC_map_update_elem:
+ return &bpf_map_update_elem_proto;
+
+ default:
+ pr_debug("Invalid fuse bpf func %d\n", func_id);
+ return NULL;
+ }
+}
+
+static bool fuse_prog_is_valid_access(int off, int size,
+ enum bpf_access_type type,
+ const struct bpf_prog *prog,
+ struct bpf_insn_access_aux *info)
+{
+ int i;
+
+ if (off < 0 || off > offsetofend(struct fuse_args, out_args))
+ return false;
+
+ /* TODO This is garbage. Do it properly */
+ for (i = 0; i < 5; i++) {
+ if (off == offsetof(struct fuse_args, in_args[i].value)) {
+ info->reg_type = PTR_TO_RDONLY_BUF;
+ info->ctx_field_size = 256;
+ if (type != BPF_READ)
+ return false;
+ return true;
+ }
+ }
+ for (i = 0; i < 3; i++) {
+ if (off == offsetof(struct fuse_args, out_args[i].value)) {
+ info->reg_type = PTR_TO_RDWR_BUF;
+ info->ctx_field_size = 256;
+ return true;
+ }
+ }
+ if (type != BPF_READ)
+ return false;
+
+ return true;
+}
+
+const struct bpf_verifier_ops fuse_verifier_ops = {
+ .get_func_proto = fuse_prog_func_proto,
+ .is_valid_access = fuse_prog_is_valid_access,
+};
+
+const struct bpf_prog_ops fuse_prog_ops = {
+};
+
diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c
index aaf2fba..5fa24b2 100644
--- a/kernel/bpf/btf.c
+++ b/kernel/bpf/btf.c
@@ -3,6 +3,7 @@
#include <uapi/linux/btf.h>
#include <uapi/linux/bpf.h>
+#include <uapi/linux/fuse.h>
#include <uapi/linux/bpf_perf_event.h>
#include <uapi/linux/types.h>
#include <linux/seq_file.h>
